Website Expiration Checker

Monitor domain expiration and website validity in bulk with one structured record per submitted domain or URL.

This website expiration checker combines authoritative RDAP registration data with live DNS, HTTP redirect, reachability, and TLS certificate evidence. It is designed for recurring portfolio monitoring, acquisition due diligence, renewal reviews, and operational inventories.

What does Website Expiration Checker do?

For every public domain or HTTP(S) URL, the Actor:

• finds the registrable domain;
• queries the authoritative RDAP service selected by the IANA bootstrap;
• extracts registration and expiration dates, registrar, and days remaining;
• resolves public A, AAAA, NS, and MX records;
• follows up to five HTTP redirects safely;
• records the final URL, status code, and response time;
• validates the HTTPS certificate and records its issuer and validity window;
• returns an overall valid, warning, or invalid status with reasons;
• records compact evidence and a checkedAt timestamp.

It does not scrape rendered page content and does not require an account, browser, proxy, or third-party API key.

Who is it for?

• Domain portfolio managers refreshing renewal and expiration inventories.
• Acquisition teams checking whether candidate domains are registered and reachable.
• IT and security teams reviewing DNS, HTTPS, and certificate health together.
• Agencies auditing client websites before migrations or maintenance work.
• Data teams feeding scheduled validity snapshots into a warehouse or spreadsheet.
• Developers who need normalized evidence instead of stitching together RDAP, DNS, HTTP, and TLS libraries.

For registration-only fields and richer RDAP entities, use Domain Registration Lookup Scraper. Choose this Actor when current website reachability and TLS validity matter alongside registration expiry.

Why combine expiration and live website checks?

A future domain expiration date does not prove that a website currently works. A domain may be registered while its DNS is broken, its HTTP endpoint is unavailable, or its TLS certificate is invalid.

Likewise, a reachable website does not show the authoritative registration expiration date.

This Actor keeps those signals separate and then derives a transparent overall status. The statusReasons and evidence fields explain the result, so downstream systems do not need to trust an opaque score.

What data can I export?

Group	Fields	Meaning
Identity	input, domain, requestedUrl, finalUrl	Submitted value and normalized destinations
Overall	status, statusReasons, error	Evidence-based summary and diagnostics
Registration	isRegistered, registrationDate, expirationDate, daysUntilExpiration, registrar	Authoritative RDAP registration evidence
RDAP	rdapStatus, rdapSourceUrl	Component status and source record
DNS	dnsStatus, ipv4Addresses, ipv6Addresses, nameservers, mxHosts	Current public DNS evidence
HTTP	httpStatus, httpStatusCode, redirectCount, responseTimeMs	Reachability and redirect result
TLS	tlsStatus, tlsValidFrom, tlsValidTo, tlsDaysUntilExpiration, tlsIssuer, tlsProtocol	Certificate and protocol evidence
Provenance	evidence, checkedAt	Compact source summary and check time

Fields can be null when a registry or protocol does not publish the corresponding value. A component failure does not erase successful evidence from other components.

How is website validity classified?

valid means the domain is registered, public DNS resolves, HTTP responds without a warning condition, TLS validates for HTTPS, and no near-expiration threshold was reached.

warning means the Actor produced useful evidence but found a concern, such as:

• an HTTP 4xx or 5xx response;
• unavailable RDAP expiry data;
• a registration expiration date within 30 days;
• a TLS expiration date within 14 days;
• an HTTP or TLS connection failure while other checks succeeded.

invalid means authoritative RDAP reports the domain as unregistered, the published registration expiration date is in the past, or the hostname has no public A/AAAA address.

This is an operational validity classification, not a legal, ownership, content-quality, or trustworthiness judgment.

How to check website expiry dates

1. Open the Actor input form.
2. Add between 1 and 1,000 domains or HTTP(S) URLs under Domains or website URLs.
3. Keep concurrency at 5 for a normal mixed portfolio.
4. Adjust the per-operation timeout only for unusually slow websites or registries.
5. Click Start.
6. Open the default dataset to inspect or export the records.
7. Schedule the task if you want recurring snapshots.

The prefilled input uses real public websites and is intentionally small enough for a quick first run.

Input parameters

targets

Required array of public domain names or HTTP(S) URLs.

Accepted examples:

[
  "apify.com",
  "https://github.com",
  "https://www.cloudflare.com/products/"
]

The Actor removes exact duplicates. URLs with credentials, IP-address targets, localhost names, private suffixes, and unsupported protocols are rejected before processing.

maxConcurrency

Optional integer from 1 to 10. Default: 5.

Lower values reduce bursts against authoritative registries. Higher values can improve throughput for a diverse portfolio but do not bypass upstream rate limits.

requestTimeoutSecs

Optional integer from 3 to 60. Default: 15.

The timeout is applied independently to RDAP, HTTP, and TLS operations. A failed component is reported in the output while independent checks continue.

Example input

{
  "targets": [
    "apify.com",
    "https://github.com",
    "cloudflare.com"
  ],
  "maxConcurrency": 3,
  "requestTimeoutSecs": 15
}

Example output

The exact dates and addresses change over time. A successful record has this shape:

{
  "input": "apify.com",
  "domain": "apify.com",
  "requestedUrl": "https://apify.com/",
  "finalUrl": "https://apify.com/",
  "status": "valid",
  "statusReasons": [],
  "isRegistered": true,
  "registrationDate": "2009-06-02T17:14:10Z",
  "expirationDate": "2035-06-02T17:14:10Z",
  "daysUntilExpiration": 3201,
  "registrar": "Amazon Registrar, Inc.",
  "rdapStatus": "ok",
  "rdapSourceUrl": "https://rdap.verisign.com/com/v1/domain/apify.com",
  "dnsStatus": "ok",
  "ipv4Addresses": ["3.164.68.53"],
  "ipv6Addresses": ["2600:9000:278c::1"],
  "nameservers": ["ns-449.awsdns-56.com"],
  "mxHosts": ["aspmx.l.google.com"],
  "httpStatus": "ok",
  "httpStatusCode": 200,
  "redirectCount": 0,
  "responseTimeMs": 97,
  "tlsStatus": "ok",
  "tlsValidFrom": "2026-07-03T00:00:00.000Z",
  "tlsValidTo": "2027-01-16T23:59:59.000Z",
  "tlsDaysUntilExpiration": 142,
  "tlsIssuer": "Amazon",
  "tlsProtocol": "TLSv1.3",
  "evidence": [
    "RDAP: https://rdap.verisign.com/com/v1/domain/apify.com",
    "DNS: 3.164.68.53",
    "HTTP: 200 https://apify.com/",
    "TLS: 2027-01-16T23:59:59.000Z"
  ],
  "checkedAt": "2026-08-27T14:08:11.000Z",
  "error": null
}

How much does it cost to check website expiration and validity?

Pay-per-event pricing has two parts:

• Run start: $0.001 once per run.
• Website checked: one event for each output record.

The BRONZE website-check price is $0.00244 per target. Tier prices decrease for higher Apify account tiers.

Approximate BRONZE examples:

Targets	Estimated Actor charge
1	$0.00344
10	$0.02540
100	$0.24500
1,000	$2.44100

These examples describe Actor charges, not external alerting, storage retention, or downstream automation costs. A malformed input that fails before records are produced does not create website-check events.

Recurring portfolio monitoring workflow

Create an Apify Task with your stable domain portfolio, then schedule it daily, weekly, or monthly.

Send each run's dataset to Google Sheets, a webhook, Make, Zapier, or your warehouse. Compare records by domain and checkedAt to detect:

• decreasing daysUntilExpiration;
• registration or registrar changes;
• DNS address or nameserver changes;
• new HTTP failures or redirects;
• TLS renewal, issuer changes, or approaching expiry.

The Actor emits snapshots. It does not store history, compare prior runs, or send alerts by itself.

Domain acquisition and due-diligence workflow

Use candidate domains as targets and filter the dataset by status, isRegistered, and httpStatus.

An RDAP 404 is evidence that the authoritative service did not find a registration at check time. It is not a guarantee that a domain is purchasable: registry policies, premium reservations, pending states, and registrar availability can differ.

Always verify an acquisition with the relevant registrar before making a purchase decision.

HTTP, redirect, and TLS safety

The Actor supports public HTTP and HTTPS hostnames only.

Before every website connection it resolves the hostname and rejects private, loopback, link-local, reserved, and non-routable destinations. The connection is pinned to a validated public IP. Redirect destinations are resolved and validated again.

The Actor follows at most five redirects and reads only enough response data to establish the status. It does not download full pages, images, scripts, video, or other browser resources.

API usage with cURL

Set APIFY_TOKEN in your environment, then run:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~website-expiration-validity-checker/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"targets":["apify.com","github.com"],"maxConcurrency":2}'

To wait for completion and receive dataset items directly:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~website-expiration-validity-checker/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"targets":["apify.com"]}'

API usage with JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/website-expiration-validity-checker').call({
  targets: ['apify.com', 'github.com'],
  maxConcurrency: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

API usage with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/website-expiration-validity-checker').call(
    run_input={
        'targets': ['apify.com', 'github.com'],
        'maxConcurrency': 2,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Use with Apify MCP

Add the Actor to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/website-expiration-validity-checker"

Claude Desktop, Cursor, and VS Code can use the equivalent HTTP MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/website-expiration-validity-checker"
    }
  }
}

Example prompts:

• “Check the registration expiry, DNS, HTTP, and TLS validity of apify.com and github.com.”
• “Run my SaaS domain portfolio task and summarize websites expiring within 30 days.”
• “Export invalid or warning records from the latest dataset.”

Limits and expected failure behavior

• A run accepts at most 1,000 targets.
• Each target produces one record when processing starts successfully.
• Authoritative registries can rate-limit or omit expiration events.
• Some country-code registries intentionally publish limited RDAP data.
• DNS and anycast addresses can change between runs.
• HTTP status is observed at check time and is not an uptime guarantee.
• A server can reject automated requests even while serving browsers.
• HTTPS URLs require a currently trusted certificate for tlsStatus=ok.
• HTTP-only URLs report TLS as not_applicable.
• The Actor does not inspect page content, WHOIS privacy records, ownership, malware, reputation, or SEO quality.

Troubleshooting

Why is rdapStatus failed but the website responds?

The website and registry are independent. The registry may not offer an IANA-listed RDAP service, may rate-limit requests, or may return limited data. HTTP, DNS, and TLS fields remain useful.

Why is a reachable page marked warning?

Inspect statusReasons. Common causes are HTTP 4xx/5xx responses, missing RDAP expiration data, or a failed/near-expiry TLS certificate.

Why did the run reject my URL?

Only public domain-based HTTP(S) targets are accepted. Remove credentials and replace IP, localhost, private-network, or unsupported-protocol targets.

How can I reduce registry rate limits?

Lower maxConcurrency, split very large portfolios by registry, or schedule batches farther apart. Residential proxies are not used and generally do not fix authoritative registry quotas.

Responsible use and legality

RDAP, DNS, HTTP headers, and public TLS certificates are public protocol data, but users remain responsible for lawful use.

Do not use the Actor to probe private networks, bypass access controls, or misrepresent operational results. Follow applicable registry terms, website terms, privacy rules, and organizational security policies.

The Actor intentionally rejects private and reserved destinations.

Related Automation Lab Actors

• Domain Registration Lookup Scraper — richer authoritative RDAP registration records without website checks.
• Website Uptime Checker — focused recurring HTTP availability checks.
• Website Lighthouse Audit — rendered performance, accessibility, best-practice, and SEO audits.
• Website HTML & Text Change Monitor — versioned page-content snapshots and changes.

FAQ

Does a website itself expire?

A website has several independently expiring or failing components. Domain registration and TLS certificates have dates; DNS and HTTP availability are current states. This Actor reports them separately.

Can I check subdomains and URL paths?

Yes. RDAP uses the registrable parent domain, while DNS, HTTP, redirects, and TLS use the submitted hostname and path.

Does it send expiration alerts?

No. Schedule runs and connect their datasets to an alerting or automation tool. The records contain thresholds and timestamps suitable for that workflow.

Does it use WHOIS scraping?

No. Registration data comes from authoritative public RDAP services selected through the IANA bootstrap.

Is an unregistered result proof that I can buy the domain?

No. Treat it as monitoring evidence and confirm availability with a registrar.

Are failed checks charged?

Each completed output row emits one websiteCheck billing event even if one component reports a failure. Inputs rejected before processing do not emit a website-check event.