Domain Age History Checker — WHOIS, Wayback Machine & DNS Lookup

Check the registration age and history of any domain. Uses public WHOIS data to find creation date, registrar, and expiration, then optionally checks the Wayback Machine CDX API for the oldest archived snapshot. Supports single domains and batch mode (up to 50 domains per run).

Built with async HTTPX for HTTP calls, RDAP as a fallback when WHOIS is unavailable, and Python's socket module for DNS resolution. No Playwright, no browser automation — this is all API-based lookups.

---

What does it do?

You give it a domain name (or a list of up to 50), and it returns a structured report: creation date, expiration date, registrar, name servers, domain age in days and years, DNS records (both IPv4 and IPv6), and registrant info where available. If you enable the Wayback Machine check, it also finds the oldest archived snapshot and tells you how many total snapshots exist.

The actor handles the messy parts automatically — validates domain format, strips protocol prefixes and ports, falls back to RDAP when the free WHOIS API rate-limits or goes down, and catches errors per domain so a single failure doesn't derail the whole batch.

---

Features

1. WHOIS data extraction — Creation date, expiration date, last-updated date, registrar, and name servers pulled from public WHOIS records.
2. Domain age calculation — Age in days and years computed from the creation date.
3. DNS resolution — A (IPv4) and AAAA (IPv6) record lookup via standard socket calls. Also flags whether the domain resolves at all.
4. Wayback Machine archive check — Optional lookup via the Internet Archive CDX API. Returns the oldest snapshot URL, its date, and the total number of archived snapshots.
5. RDAP fallback — If the free WHOIS API is unreachable or rate-limited, the actor automatically switches to RDAP queries. Handles .com, .net, .org, .info, .biz via Verisign, .uk/.co.uk/.org.uk via Nominet, .de via DENIC, and everything else via rdap.org.
6. Batch mode — Process up to 50 domains in a single run. Each domain is looked up concurrently (max 5 at a time) with WHOIS, DNS, and optional Wayback checks.
7. Registrant info — Organization name and country are extracted when available in WHOIS or RDAP data.
8. DNSSEC status — Returns DNSSEC signing information when the registry provides it.
9. Graceful error isolation — A failed lookup for one domain doesn't block the others. Failed domains return with an error field describing what went wrong.

---

Input Parameters

Field	Type	Required	Default	Description
mode	string (enum)	Yes	single	Either single or batch
domain	string	If mode=single	—	The domain to analyse (e.g., example.com). Accepts bare domains or URLs with protocol prefixes.
domains	array of strings	If mode=batch	[]	List of domains (max 50). Each entry is cleaned the same way as the single domain field.
check_wayback	boolean	No	false	Set to true to enable Wayback Machine archive lookup (oldest snapshot + total count).

Example Input

{
  "mode": "single",
  "domain": "example.com",
  "check_wayback": true
}

Batch Mode Example

{
  "mode": "batch",
  "domains": ["example.com", "example.org", "example.net"],
  "check_wayback": false
}

---

Output Format

Each domain in the result set contains the following fields:

Field	Type	Description
domain	string	The domain name queried
creation_date	string	ISO 8601 domain creation date (from WHOIS or RDAP)
expiration_date	string	ISO 8601 domain expiration date
updated_date	string	ISO 8601 last update date
domain_age_days	integer	Domain age in days
domain_age_years	number	Domain age in years (rounded to 1 decimal)
registrar	string	Domain registrar name
name_servers	array	List of name servers
registrant_org	string	Registrant organization (where available)
registrant_country	string	Registrant country code (where available)
dnssec	string	DNSSEC status (e.g., signedDelegation)
whois_available	boolean	Whether WHOIS or RDAP data was found
a_records	array	IPv4 addresses the domain resolves to
aaaa_records	array	IPv6 addresses the domain resolves to
resolvable	boolean	Whether the domain has at least one DNS record
wayback_available	boolean	Whether Wayback data was found (only if check_wayback is enabled)
oldest_snapshot_url	string	URL of the oldest Wayback Machine snapshot
oldest_snapshot_date	string	ISO 8601 date of the oldest snapshot
snapshot_count	integer	Total number of Wayback snapshots
error	string	Error message if the lookup failed for this domain

Example Output

{
  "domain": "example.com",
  "creation_date": "1997-09-15T04:00:00Z",
  "expiration_date": "2032-09-14T04:00:00Z",
  "updated_date": "2024-08-21T04:00:00Z",
  "domain_age_days": 9850,
  "domain_age_years": 26.98,
  "registrar": "Internet Assigned Numbers Authority",
  "name_servers": ["a.iana-servers.net", "b.iana-servers.net"],
  "registrant_org": "Internet Assigned Numbers Authority",
  "registrant_country": "US",
  "dnssec": "signedDelegation",
  "whois_available": true,
  "a_records": ["93.184.216.34"],
  "aaaa_records": ["2606:2800:21f:cb07:6820:80da:af6b:8b2c"],
  "resolvable": true,
  "wayback_available": true,
  "oldest_snapshot_url": "http://web.archive.org/web/19980516163034/http://www.example.com/",
  "oldest_snapshot_date": "1998-05-16T16:30:34Z",
  "snapshot_count": 4827
}

---

Why use this?

Pain Point	How This Actor Solves It
Manually running WHOIS lookups one domain at a time is slow and tedious	Batch processes up to 50 domains in a single run with automated WHOIS + RDAP fallback
You don't know if a domain is days old (phishing risk) or decades old (established site)	Checks domain creation date and Wayback history so you can assess legitimacy at a glance
No way to see what content a domain hosted years ago	Integrates Wayback Machine CDX API to surface the oldest archived snapshot and total archive count
Expired or privacy-protected domains often return incomplete WHOIS data	Automatic RDAP fallback across 5+ TLD authorities, plus DNSSEC and registrant info extraction
Wasting time on domains that don't resolve	Built-in DNS resolution (A + AAAA) immediately shows whether the domain is live
Registrar data formats vary wildly between registries	Unified parser handles JSON and raw text WHOIS responses from whois.free.fr, plus structured RDAP responses
Need to check domain age programmatically at scale	API-first design with cURL, Python, and Node.js examples plus MCP server support

---

Who is it for?

Persona	What They Use It For
SEO Professional	Evaluating domain age as a ranking signal, checking if a domain has been abandoned or penalised
Cybersecurity Analyst	Detecting phishing domains registered a few days ago that impersonate legitimate brands
Domain Investor	Assessing the age and historical content of domains before buying at auction
Digital Forensics Investigator	Tracing the earliest known content on a domain via Wayback Machine snapshots
Website Buyer	Verifying seller claims about domain age and registration history before acquisition
Compliance Officer	Auditing domain registration ages across a corporate portfolio for policy violations
Marketing Researcher	Analysing competitor domain registration dates to understand market entry timing
IT Administrator	Monitoring domain expiration dates across the organisation's portfolio

---

API Usage

You can run the actor programmatically via the Apify API.

cURL

curl -X POST "https://api.apify.com/v2/acts/perryay~domain-age-history-checker/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "mode": "single",
    "domain": "example.com",
    "check_wayback": true
  }'

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

result = client.actor("perryay/domain-age-history-checker").call(
    run_input={
        "mode": "single",
        "domain": "example.com",
        "check_wayback": True,
    }
)

dataset_items = client.dataset(result["defaultDatasetId"]).list_items()
for item in dataset_items.items:
    print(f"Domain: {item['domain']}")
    print(f"Age: {item['domain_age_years']} years")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const result = await client.actor('perryay/domain-age-history-checker').call({
    mode: 'single',
    domain: 'example.com',
    check_wayback: true,
});

const { items } = await client.dataset(result.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`Domain: ${item.domain}`);
    console.log(`Age: ${item.domain_age_years} years`);
});

---

FAQ

1. What data sources does this actor use?

It queries the free WHOIS API at whois.free.fr (with JSON parsing and raw-text fallback), RDAP endpoints for .com/.net/.org/.info/.biz (Verisign), .uk (Nominet), .de (DENIC), and a catch-all via rdap.org. DNS uses Python's socket module for A and AAAA records. Historical snapshots come from the Internet Archive CDX API.

2. How accurate is the domain age?

Domain age is calculated from the creation date returned by WHOIS or RDAP. Registrars set this date, and it's generally accurate. Very old domains may show the date ICANN started mandating WHOIS rather than the original registration date, so domains registered before ~2000 can sometimes show a later date.

3. Why do some domains return no WHOIS data?

Some registrars block WHOIS queries, the domain may use privacy protection services, or the free WHOIS API rate limit may have been exceeded. The actor falls back to RDAP automatically in these cases. If both sources fail, the whois_available field will be false.

4. How does the Wayback Machine integration work?

When check_wayback is enabled, the actor sends a query to the Internet Archive CDX API requesting the oldest snapshot of the domain. It also makes a second call with showNumPages=true to get the total snapshot count. Results include the snapshot URL, date, and count.

5. Can I check private or expired domains?

Yes. Private WHOIS records still often reveal creation and expiration dates — the registrant contact details are what gets hidden, not the registration dates. Expired domains usually still have public WHOIS data and Wayback snapshots.

6. What's the maximum number of domains I can check at once?

Batch mode supports up to 50 domains per run. Each domain is processed with up to 5 concurrent lookups. For larger lists, split them into multiple runs or orchestrate parallel executions via the Apify API.

7. Does this actor work with subdomains?

It accepts any valid domain format including subdomains (the input parser strips protocol prefixes and ports). However, WHOIS data operates at the registered domain level, so sub.example.com will return the same WHOIS/RDAP data as example.com. The DNS resolution and Wayback checks do work at the subdomain level.

8. What does "RDAP fallback" actually do?

RDAP (Registration Data Access Protocol) is a modern replacement for WHOIS. The actor first tries the whois.free.fr API. If that fails (timeout, non-200 response, or empty result), it automatically tries RDAP using a TLD-specific endpoint: Verisign for .com/.net/.org/.info/.biz, Nominet for .uk, DENIC for .de, and rdap.org as a fallback for everything else.

9. What happens when a domain lookup fails?

Errors are caught per domain and returned as an error field in that domain's result. Other domains in a batch run are completely unaffected — one failure won't stop the rest. The summary at the end of the run logs how many succeeded and how many had errors.

10. Does the actor store historical results?

Each run creates a new dataset on Apify. The results are available via the Apify Console or the API until the dataset retention period expires. Results are not shared between different users or runs.

---

Use Cases

1. SEO assessment — Older domains tend to rank better. Check domain age before buying or evaluating a site for link-building.
2. Lead qualification — Newly registered domains may indicate spam or low-authority sites. Filter them out before investing time.
3. Phishing detection — A domain registered 48 hours ago that looks like your bank's login page is almost certainly a phishing site.
4. Competitive research — Find out when competitors registered their domains to understand market entry timing.
5. Domain portfolio management — Track expiration dates across multiple domains to avoid losing valuable names.
6. Content discovery — Use the Wayback Machine integration to see what a domain looked like when it was first archived.
7. Website flipping due diligence — Before buying an established site, verify the domain's registration history and earliest known content against the seller's claims.
8. Brand protection monitoring — Scan newly registered domains containing your brand name to identify cybersquatting and trademark infringement early.

---

MCP Integration

{
  "mcpServers": {
    "apify-domain-age": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-server-actors", "--actors=perryay/domain-age-history-checker"]
    }
  }
}

---

Related Tools

• Domain Intel — WHOIS, DNS & SSL — Comprehensive domain intelligence with WHOIS, DNS records, and SSL certificate data
• IP Geo — IP Geolocation & ISP Lookup — IP address geolocation and ISP detection

---

SEO Keywords

Domain age checker, WHOIS lookup, domain creation date, domain history checker, Wayback Machine lookup, domain registration date, domain age API, bulk WHOIS checker, DNS resolver, domain portfolio tool, SEO domain analysis, phishing domain detection