Domain Age Checker

Check domain registration age and dates using RDAP protocol.

What does Domain Age Checker do?

Domain Age Checker retrieves domain registration data using the RDAP (Registration Data Access Protocol) -- the modern, structured replacement for WHOIS. It returns the registration date, expiration date, registrar, nameservers, domain status, and calculates the domain age in both days and years. Supports .com, .net, .org, .io, .dev, .app, and many other TLDs.

Use it for domain research, SEO analysis, fraud detection, competitive intelligence, or any workflow that needs to know how long a domain has been registered. The structured JSON output makes it easy to filter, sort, and analyze domain age data at scale.

Use cases

• Domain investors evaluating how old a domain is before deciding to purchase it
• SEO professionals checking domain age as a trust signal when auditing backlink profiles
• Fraud analysts flagging newly registered domains that may be associated with phishing or spam
• Competitive researchers determining when competitors registered their domains and planning brand expansion
• Compliance teams verifying domain registration longevity as part of vendor due diligence

Why use Domain Age Checker?

• Modern RDAP protocol — uses the structured RDAP API instead of legacy WHOIS text parsing, providing more reliable results
• Age calculation built in — returns age in both days and years, so you do not need to calculate it yourself
• Expiration tracking — see when a domain expires to catch upcoming renewals or acquisition opportunities
• Batch processing — check hundreds of domains in a single run
• Broad TLD support — works with .com, .net, .org, .io, .dev, .app, and many other top-level domains
• Pay-per-event pricing — costs scale with actual usage, just $0.001 per domain checked
• Structured JSON output — parsed fields ready for filtering, sorting, and integration with downstream tools

Input parameters

Parameter	Type	Required	Default	Description
domains	string[]	Yes	—	List of domains to check age for. Enter bare domain names (e.g., google.com).

Example input

{
    "domains": [
        "google.com",
        "github.com",
        "example.com"
    ]
}

Output example

Each domain produces one result object with age calculations, registration and expiration dates, registrar information, nameservers, and status codes.

Field	Description
domain	The queried domain name
ageDays	Domain age in days since registration
ageYears	Domain age in years (decimal)
registrationDate	Original registration date (ISO 8601)
expirationDate	Expiration date (ISO 8601)
registrar	Registrar name
nameservers	Authoritative name servers
status	Domain status codes
error	Error message if lookup failed
checkedAt	ISO timestamp of the check

{
    "domain": "google.com",
    "ageDays": 9862,
    "ageYears": 27.0,
    "registrationDate": "1997-09-15T04:00:00Z",
    "expirationDate": "2028-09-14T04:00:00Z",
    "registrar": "MarkMonitor Inc.",
    "nameservers": ["ns1.google.com", "ns2.google.com"],
    "status": ["client delete prohibited", "client transfer prohibited"],
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}

How much does it cost?

Domain Age Checker uses Apify's pay-per-event pricing:

Event	Price	Description
Start	$0.035	One-time per run
Domain checked	$0.001	Per domain checked

Examples:

• 10 domains: $0.035 + 10 x $0.001 = $0.045
• 100 domains: $0.035 + 100 x $0.001 = $0.135
• 1,000 domains: $0.035 + 1,000 x $0.001 = $1.035

Using the Apify API

The Apify API lets you control Domain Age Checker programmatically. Schedule runs, read datasets, manage webhooks, and more. See the Apify API reference for details.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('automation-lab/domain-age-checker').call({
    domains: ['google.com', 'github.com'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('<YOUR_API_TOKEN>')
run = client.actor('automation-lab/domain-age-checker').call(run_input={
    'domains': ['google.com', 'github.com'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Connect Domain Age Checker with other apps and services using Apify integrations. You can integrate with Make, Zapier, Slack, Google Sheets, Google Drive, n8n, and many more. Use webhooks to trigger actions whenever a run finishes — for example, sending domain age data to a Google Sheet for SEO analysis or alerting via Slack when a domain in your watchlist is about to expire.

Tips and best practices

• Use for lead qualification — domain age is a useful signal for determining whether a business is established or newly created
• Combine with WHOIS Lookup — if you need registrant contact info in addition to age, use WHOIS Lookup for the full picture
• Schedule periodic checks — set up weekly runs to monitor expiration dates across your domain portfolio and catch renewals early
• Filter by age in downstream tools — export to Google Sheets or a database and filter for domains older or newer than a threshold
• Check TLD support — while most common TLDs are supported, some country-code TLDs may not have RDAP servers; the error field will indicate when a lookup fails
• Export and sort by age — download results as JSON, CSV, or Excel and sort by ageDays to quickly identify the oldest or newest domains in your list

FAQ

What is the difference between RDAP and WHOIS? RDAP is the modern replacement for WHOIS. It returns structured JSON data instead of unformatted text, making it more reliable for automated processing. Domain Age Checker uses RDAP for accuracy and consistency.

What happens if a domain is not found? If the domain does not exist or the TLD has no RDAP server, the result will include an error field explaining the failure. Other domains in the batch are not affected.

Can I check domain age for country-code TLDs like .uk or .de? Support depends on whether the TLD registry provides an RDAP endpoint. Most major TLDs are supported, but some country-code TLDs may not be available yet.

How accurate is the age calculation? The age is calculated from the registration date returned by the RDAP server to the time of the check. It is as accurate as the data provided by the domain registry. The ageDays field is an integer count of days, and ageYears is a decimal for convenience.

Does the actor show when a domain will expire? Yes. The expirationDate field contains the expiry date as an ISO 8601 timestamp. You can use this to track upcoming renewals or identify domains that may become available for registration after they expire.