# Domain Age History Checker — WHOIS & Wayback Lookup (`perryay/domain-age-history-checker`) Actor Check the registration age and history of any domain using WHOIS data and Wayback Machine archives. Returns creation date, expiration date, registrar, DNS records, domain age in days/years, and oldest archived snapshot. Supports single and batch mode up to 50 domains. - **URL**: https://apify.com/perryay/domain-age-history-checker.md - **Developed by:** [Perry AY](https://apify.com/perryay) (community) - **Categories:** Developer tools, SEO tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.025 / actor start This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use 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 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 ```json { "mode": "single", "domain": "example.com", "check_wayback": true } ```` #### Batch Mode Example ```json { "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 ```json { "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 ```bash 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 ```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 ```javascript 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 ```json { "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](https://apify.com/perryay/domain-intel)** — Comprehensive domain intelligence with WHOIS, DNS records, and SSL certificate data - **[IP Geo — IP Geolocation & ISP Lookup](https://apify.com/perryay/ip-geo)** — 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 # Actor input Schema ## `mode` (type: `string`): Choose single domain lookup or batch processing of multiple domains. ## `domain` (type: `string`): The domain to analyze (e.g., example.com). Accepts bare domains or URLs. ## `domains` (type: `array`): List of domains to analyze in batch mode (max 50). ## `check_wayback` (type: `boolean`): Enable Wayback Machine archive lookup for the oldest snapshot and total snapshot count. ## Actor input object example ```json { "mode": "single", "domain": "example.com", "domains": [ "example.com", "example.org" ], "check_wayback": false } ``` # Actor output Schema ## `results` (type: `string`): Domain analysis results delivered via the default dataset # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "mode": "single", "domain": "example.com", "domains": [ "example.com", "example.org" ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/domain-age-history-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "mode": "single", "domain": "example.com", "domains": [ "example.com", "example.org", ], } # Run the Actor and wait for it to finish run = client.actor("perryay/domain-age-history-checker").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "mode": "single", "domain": "example.com", "domains": [ "example.com", "example.org" ] }' | apify call perryay/domain-age-history-checker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/domain-age-history-checker", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Domain Age History Checker — WHOIS & Wayback Lookup", "description": "Check the registration age and history of any domain using WHOIS data and Wayback Machine archives. Returns creation date, expiration date, registrar, DNS records, domain age in days/years, and oldest archived snapshot. Supports single and batch mode up to 50 domains.", "version": "1.0", "x-build-id": "89waYDjZxEYQmxPjs" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~domain-age-history-checker/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-domain-age-history-checker", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/perryay~domain-age-history-checker/runs": { "post": { "operationId": "runs-sync-perryay-domain-age-history-checker", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/perryay~domain-age-history-checker/run-sync": { "post": { "operationId": "run-sync-perryay-domain-age-history-checker", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "mode" ], "properties": { "mode": { "title": "Analysis Mode", "enum": [ "single", "batch" ], "type": "string", "description": "Choose single domain lookup or batch processing of multiple domains.", "default": "single" }, "domain": { "title": "Domain Name", "type": "string", "description": "The domain to analyze (e.g., example.com). Accepts bare domains or URLs.", "default": "" }, "domains": { "title": "Domain List (Batch Mode)", "type": "array", "description": "List of domains to analyze in batch mode (max 50).", "items": { "type": "string" }, "default": [] }, "check_wayback": { "title": "Check Wayback Machine History", "type": "boolean", "description": "Enable Wayback Machine archive lookup for the oldest snapshot and total snapshot count.", "default": false } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```