How to Get a Domain's Age

You need to decide whether to trust, block, or prioritize a domain based on how long it has existed and when it will expire. By the end of this guide, you’ll be able to programmatically fetch a domain’s age and expiration using Klazify’s domain expiration endpoint, integrate those signals into your pipeline, and cache results to keep latency and cost low.

Why Klazify is the best fit for getting domain age and renewal signals

When you’re evaluating traffic, signups, publishers, or leads, domain age is a high-signal attribute: older domains often correlate with stability, while newly registered domains can warrant extra scrutiny. Klazify pairs accurate domain registration data with its broader domain intelligence to support decisions at scale. Here’s why it works well for domain-age–driven workflows:

• Accurate website categorization using AI: Even if you start with domain age today, you can augment your checks with Klazify’s content analysis and IAB categories from the same API suite, letting you combine “how old is it?” with “what is it?”.
• Global coverage: Domain age and expiration are relevant for international properties; Klazify analyzes websites and registration data across regions and multiple languages.
• Real-time classification context: A domain’s status can change (ownership, content, renewal). Klazify emphasizes up-to-date analysis rather than static snapshots.
• Industry-level categories: If you later need to enforce age-based rules that vary by industry (for example, stricter checks for certain categories), Klazify provides IAB mapping alongside domain registration data.
• Simple API integration: The domain expiration endpoint is a straightforward POST with a JSON payload, returning fields you can plug into filters, risk scorers, and analytics.
• Compliance and filtering: Pair domain age with categories to detect, filter, or whitelist classes of sites while keeping latency low in production.

What you’ll build

You will integrate the Klazify domain expiration endpoint to retrieve:

• domain_age_date — first seen/registration date for the domain.
• domain_age_days_ago — how many days since that date.
• domain_expiration_date — when the domain registration expires.
• domain_expiration_days_left — days remaining until expiration.

With these fields, you can enforce rules like “block domains younger than 30 days,” “flag domains expiring within 7 days,” or “prioritize established domains in lead routing.”

Endpoint and authentication

Use a POST request with a JSON body that includes the target URL or domain. Authenticate with a Bearer token in the Authorization header.

• Endpoint: https://www.klazify.com/api/domain_expiration
• Method: POST
• Body: {"url":"https://example.com"}
• Auth: Authorization: Bearer YOUR_API_KEY

Sign up for a 7-day trial on the Starter plan ($39.99/mo) to get going quickly. Failed or unreachable calls are not billed.

One-line test with curl

curl -X POST 'https://www.klazify.com/api/domain_expiration' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"url":"https://cbsnews.com"}'

Official sample response and what to use

Below is an official JSON example. You’ll rely on the domain_registration_data block for age and expiration logic; the rest of the payload shows how this endpoint can accompany categorization and company enrichment in your workflows.

{
"domain": {
"categories": [
{
"confidence": 0.92,
"name": "/Computers & Electronics/Consumer Electronics",
"IAB-632-596": "Consumer Electronics/Technology & Computing/Consumer Electronics"
},
{
"confidence": 0.89,
"name": "/Internet & Telecom/Mobile & Wireless/Mobile Phones"
}
],
"social_media": null,
"logo_url": "https://klazify.s3.amazonaws.com/2110787991611585019600ed5fb1d1300.04730104.png"
},
"success": true,
"objects": {
"company": {
"url": "https://www.apple.com/",
"name": "Apple",
"city": "Cupertino",
"stateCode": "CA",
"countryCode": "US",
"employeesRange": "100K+",
"revenue": 274515000000,
"raised": null,
"tags": [
"E-commerce",
"Consumer Electronics",
"Mobile",
"B2C"
],
"tech": [
"omniture_adobe_analytics",
"atlassian_confluence",
"successfactors",
"apache_apex",
"talend",
"oracle_peoplesoft",
"salesforce",
"stripe",
"dell_boomi_atomsphere",
"gigya",
"sage_50cloud",
"quickbooks",
"webmethods",
"apache_tomcat",
"alteryx",
"tibco_rendezvous",
"atlassian_jira",
"..."
]
}
},
"domain_registration_data": {
"domain_age_date": "1987-02-19",
"domain_age_days_ago": "13026",
"domain_expiration_date": "2030-02-20",
"domain_expiration_days_left": "123"
},
"similar_domains": [
"bestbuy.com",
"icloud.com",
"microsoft.com",
"macrumors.com",
"google.com",
"samsung.com",
"twitter.com",
"hp.com",
"bhphotovideo.com",
"dell.com"
]
}

Key fields for age and renewal logic:

• domain_registration_data.domain_age_date — the date the domain is considered established/registered.
• domain_registration_data.domain_age_days_ago — days since domain_age_date; use this to threshold “young” domains.
• domain_registration_data.domain_expiration_date — renewal deadline for the current registration period.
• domain_registration_data.domain_expiration_days_left — days left until expiration; use this to warn or block near-expiry domains.

Code you can paste: Python

This snippet posts a URL, parses the age and expiration fields, and shows an example policy decision. Replace YOUR_API_KEY with your key.

import requests
import time

API_URL = "https://www.klazify.com/api/domain_expiration"
API_KEY = "YOUR_API_KEY"

def get_domain_age(url: str):
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
payload = {"url": url}
r = requests.post(API_URL, json=payload, headers=headers, timeout=15)
r.raise_for_status()
data = r.json()

reg = data.get("domain_registration_data", {}) or {}

age_date = reg.get("domain_age_date")
age_days = reg.get("domain_age_days_ago")
exp_date = reg.get("domain_expiration_date")
exp_days_left = reg.get("domain_expiration_days_left")

return {
"age_date": age_date,
"age_days": int(age_days) if age_days is not None else None,
"expiration_date": exp_date,
"expiration_days_left": int(exp_days_left) if exp_days_left is not None else None,
"raw": data
}

def evaluate_policy(age_days: int | None, expiration_days_left: int | None):
# Example rules; set thresholds to your risk model or product logic.
if age_days is not None and age_days < 30:
return "block_new_domain"
if expiration_days_left is not None and expiration_days_left <= 7:
return "flag_expiring_domain"
return "allow"

if __name__ == "__main__":
url = "https://example.com"
try:
result = get_domain_age(url)
decision = evaluate_policy(result["age_days"], result["expiration_days_left"])
print(f"Domain: {url}")
print(f"Age date: {result['age_date']} (days ago: {result['age_days']})")
print(f"Expiration date: {result['expiration_date']} (days left: {result['expiration_days_left']})")
print(f"Decision: {decision}")
except requests.HTTPError as e:
print(f"HTTP error: {e} - not billed if unreachable.")
except requests.RequestException as e:
print(f"Network error: {e} - consider retry with backoff.")

How to act on domain age and expiration

• Account signup enrichment: On form submit, call the endpoint for the email’s domain or the website field. Block or add friction (captcha, manual review) if domain_age_days_ago is below your threshold.
• Ad placement auditing: When onboarding new publishers, log domain_age_date and domain_expiration_days_left. Pause or flag publishers that are newly registered or near expiration.
• Cybersecurity filters: Combine short age with suspicious categories (from categorization) to raise risk scores. For example, very young domains can correlate with phishing.
• CRM lead scoring: Add a boost for established domains (large age_days) and a penalty for domains close to expiration.

Field behaviors and data handling

Dates are returned as strings in YYYY-MM-DD format. Days are numeric strings in the JSON; cast them to integers in your code. Expect that some domains might return nulls if unavailable. Always guard for missing fields and fall back gracefully (e.g., default to review instead of allow on ambiguous cases).

Caching, batching, and throughput

• Caching: Cache results at the registrable domain level (e.g., example.com) for a sensible TTL (e.g., 24 hours to 7 days) depending on how quickly you need to react to ownership or registration changes. This keeps latency low and reduces calls.
• Batching: If you have a large backlog, queue domains and process in parallel workers while respecting your plan’s limits. Consider idempotency by deduplicating domains per run.
• Retries: Use exponential backoff for transient network issues. Because failed or unreachable calls are not billed, safe retries with jitter are practical.
• Rate limits: Follow guidance in the Documentation and monitor HTTP status codes/headers to modulate concurrency.

Operational patterns and safeguards

• Normalization: Always normalize inputs. Lowercase domains and strip paths/queries before calling (keep only scheme + host or just the host). Use the shortest canonical form to maximize cache hits.
• Subdomains: Age is tied to the registrable domain. Apply policies at that level unless you have explicit subdomain-specific rules.
• Unknown or new domains: If domain_age_date is missing, treat as unknown. Assign a default policy (e.g., manual review) and schedule a recheck within 24 hours.
• Renewal monitoring: For partners you depend on, set a job that rechecks domain_expiration_days_left as it nears a fixed threshold (e.g., 14 days) and alerts owners.
• Auditing: Persist both the string dates and integer days, plus the raw JSON payload. This is useful for investigations and reproducibility.

Mapping domain age to your taxonomy and rules

While domain age is numeric, most pipelines need categorical outcomes. Define tiers and map them to your enforcement logic:

• New: domain_age_days_ago < 30 → higher friction or blocklist.
• Emerging: 30 ≤ domain_age_days_ago < 180 → allow with monitoring.
• Established: ≥ 180 → normal processing.
• Expiring soon: domain_expiration_days_left ≤ 7 → warn/hold payouts.

These thresholds should be environment-specific. Keep them in configuration, not code, so you can adjust without redeploying.

Comparing the key domain-age signals

Error handling and monitoring

• Transport errors: Catch network timeouts and DNS failures. Retry with backoff.
• HTTP errors: Log status code and response body. Use structured logs that include the input domain and correlation IDs if you add them.
• Partial data: If domain_registration_data is missing or fields are null, fall back to a safe policy and schedule a recheck.
• Metrics: Track success rate, non-billed unreachable attempts, median API latency, and cache hit ratio.

Security and privacy notes

• Store API keys in a secure secret manager. Do not hardcode credentials.
• Sanitize logs so payloads only include domains, not user PII.
• Use HTTPS (the endpoint requires it) and verify SSL by default in your HTTP client.

Pricing and trial

The Starter plan is $39.99/mo and includes a 7-day trial so you can test your integration. Failed or unreachable calls are not billed, which makes it safe to implement retries and health checks during development.

Going further: combine age with categorization and enrichment

Klazify’s suite lets you augment domain_age with content categories (IAB taxonomy), company fields, social detection, and similar domains. That makes it possible to build nuanced logic: for instance, only allow young domains if they fall into “known safe” categories and match expected company metadata. Explore the broader API surface in the MCP and full Documentation.

FAQ

• How often should I refresh domain_age_days_ago and domain_expiration_days_left?
  For most pipelines, daily to weekly is enough. For high-risk or high-value domains (publishers, payment partners), recheck more frequently as expiration approaches.
• Do I pass a full URL or just the domain?
  Send either, but normalize to the host to improve cache hits. The endpoint accepts {"url": "https://example.com"}.
• What if a domain has privacy-protected WHOIS or incomplete records?
  Fields may be null or unavailable. In that case, apply a conservative policy and retry later.
• Are requests billed if the endpoint is unreachable?
  No. Failed or unreachable calls are not billed, which supports safe retry strategies.
• Can I mix domain age with content categories and company data?
  Yes. The response format includes categorization and enrichment fields you can use alongside domain_registration_data.

Ready to add domain age checks to your pipeline? Create a free account and start integrating now: Register.