# Domain Expiry, SSL Certificate & DMARC Checker (Bulk) (`zahidthani/domain-health-checker`) Actor

Bulk-check domains for registration expiry, SSL certificate expiry and errors, and email security (SPF, DMARC, DKIM). Each domain gets an issues list and an ok / warning / critical status. Schedule it weekly to hear only about problems. About $2 per 1,000 domains.

- **URL**: https://apify.com/zahidthani/domain-health-checker.md
- **Developed by:** [Zahid Thani](https://apify.com/zahidthani) (community)
- **Categories:** Developer tools, SEO tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 domain checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Domain Expiry, SSL Certificate & DMARC Checker (Bulk)

**Paste a list of domains and find out which ones need attention: domains about to expire, SSL certificates that are
expired or expiring soon, and email set up without SPF or DMARC. Every domain gets a plain-English issues list and an
`ok` / `warning` / `critical` status, so you can sort a whole client list in one click.**

**What it costs, in plain terms:** checking 25 domains costs about 5 cents; 1,000 domains cost about $2. The form
opens with 3 example domains, so your first run costs less than 1 cent and works with one click on **Start**.

### Sample output (real run, 9 November 2026)

| domain | status | issues | expiryDate | domainDaysLeft | sslDaysLeft | mailProvider | dmarcPolicy |
|---|---|---|---|---|---|---|---|
| apify.com | ok | (none) | 2035-06-02 | 3127 | 68 | Google Workspace | reject |
| docs.python.org | warning | DMARC policy is p=none (monitoring only, spoofed mail isn't blocked) | 2033-03-28 | 2331 | 97 | | none |
| expired.badssl.com | critical | SSL certificate problem: certificate has expired; No DMARC record | 2027-04-07 | 149 | -4229 | | |

`expired.badssl.com` is a public test site with a deliberately expired certificate. Each row also has the registrar,
SSL issuer, name servers, MX, SPF and DKIM details (full field list below).

### What can this domain checker do?

- 📅 **Domain registration**: registrar, created, updated and expiry dates, days left, domain status codes (catches
  `redemption period`, `pending delete`, `client hold`), name servers and DNSSEC.
- 🔒 **SSL certificate**: valid or not (expired, self-signed, wrong name...), issuer, expiry date, days left, the names
  it covers and the TLS version. Checks the bare domain, then `www.` if the bare domain doesn't serve HTTPS.
- ✉️ **Email security**: MX servers and provider (Google Workspace, Microsoft 365, Zoho...), the SPF record and its
  common mistakes (`+all`, two SPF records, too many lookups), the DMARC record and policy, and DKIM keys under common selectors.
- 🚦 **Issues and status**: things expiring within your warning window, SSL problems, missing or weak SPF/DMARC.
  `critical` means act now (expired, expiring in 7 days or less, broken certificate, SPF `+all`).
- ⏰ **Built for schedules**: run it weekly with **Only output domains with issues** and connect an email, Slack or
  webhook integration. You hear only when something needs attention.

### Who uses it

- **Agencies and IT providers:** watch every client domain and certificate so nothing lapses unnoticed.
- **Email deliverability:** Gmail and Yahoo require SPF, DKIM and DMARC from bulk senders. Check a list of sending
  domains in one run.
- **Domain portfolios:** expiry dates and registrar for hundreds of domains, in one table.
- **Sales prospecting (email security, web services):** find companies with no DMARC record, expiring certificates or
  domains about to lapse. The data is about domains, not people.

### How to use it

1. Click **Try for free**.
2. Paste domains, URLs or work emails, one per line. Only the domain is used, and duplicates are removed.
3. Set **Warn this many days before expiry** (30 by default).
4. Click **Start**. 100 domains take about a minute.
5. Sort the **Overview** table by `status`, or export CSV/Excel/JSON.

### Get a weekly expiry alert (about 3 minutes to set up)

1. Paste your domains and turn on **Only output domains with issues**.
2. Click **Save as a new task**, then on the task open **Schedule** and pick weekly.
3. On the task's **Integrations** tab, add email or Slack (or a webhook). In weeks where nothing is wrong the run
   has no rows, so any row in the result is something to fix. The run's status message also gives the counts
   (for example "2 critical, 5 warning, 18 ok").

25 domains checked weekly cost about $0.20 a month.

### Input example

```json
{
  "domains": ["example.com", "https://shop.example.co.uk", "jane@example.org"],
  "expiryWarningDays": 30,
  "onlyIssues": false
}
```

### Output example (every field)

The values below are illustrative; the sample table at the top is from a real run.

```json
{
  "type": "domain",
  "domain": "example.com",
  "status": "warning",
  "issues": ["SSL certificate expires in 12 days", "DMARC policy is p=none (monitoring only, spoofed mail isn't blocked)"],
  "registered": true,
  "registeredDomain": "example.com",
  "registrar": "Example Registrar, Inc.",
  "registrarIanaId": "000",
  "createdDate": "2004-05-11",
  "expiryDate": "2027-05-11",
  "domainDaysLeft": 184,
  "domainStatus": ["client transfer prohibited"],
  "nameservers": ["ns1.example-dns.com", "ns2.example-dns.com"],
  "dnssec": false,
  "sslHost": "example.com",
  "sslValid": true,
  "sslIssuer": "Let's Encrypt",
  "sslExpiryDate": "2026-11-20",
  "sslDaysLeft": 12,
  "tlsVersion": "TLSv1.3",
  "mx": ["aspmx.l.google.com", "alt1.aspmx.l.google.com"],
  "mailProvider": "Google Workspace",
  "spf": "v=spf1 include:_spf.google.com ~all",
  "spfIssues": [],
  "dmarc": "v=DMARC1; p=none; rua=mailto:dmarc@example.com",
  "dmarcPolicy": "none",
  "dmarcReports": true,
  "dkimSelectors": ["google"]
}
```

### How much does it cost?

| Event | Price | Per 1,000 |
|---|---|---|
| Domain checked | $0.002 | **$2.00** |
| Run start | $0.0005 | - |

| Job | Cost |
|---|---|
| 25 client domains, weekly for a month | about $0.20 |
| 1,000 domains | about $2.00 |

Invalid inputs and domains where no check could run at all are free. With **Only output domains with issues**, every
domain is still checked and charged, but healthy ones aren't listed. Set **Maximum cost per run** and the Actor stops
cleanly at your budget.

**Try it free:** a new Apify account costs nothing, needs no credit card, and includes $5 of usage every month.
That covers about 2,500 domain checks.

### How it compares

| | This Actor | Free one-at-a-time checkers (MXToolbox, SSL Labs, WHOIS sites) | Uptime / SSL monitoring subscriptions |
|---|---|---|---|
| Domain expiry + SSL + SPF/DMARC in one row | **Yes** | No, one tool per check | Usually SSL only |
| A list of hundreds of domains in one run | Yes | No | Yes, on paid tiers |
| Weekly alert with only the problems | Yes (task + schedule) | No | Yes |
| Cost for 25 domains checked weekly | about $0.20 a month | Free, but manual | Monthly plan |
| Deep SSL grading (cipher suites, A+ to F) | No | **Yes** (SSL Labs) | Varies |

If you only need to check one domain once, a free single-domain checker is fine. This Actor is for lists and schedules.

### Use it with AI agents (MCP) and the API

Connect it via `https://mcp.apify.com?tools=zahidthani/domain-health-checker` and ask, for example:

> Which of my 40 client domains or SSL certificates expire in the next 60 days, and which have no DMARC?

```bash
curl -X POST "https://api.apify.com/v2/acts/zahidthani~domain-health-checker/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"domains": ["example.com", "example.org"], "onlyIssues": true}'
```

### Limits and tips

- **Registration data comes from RDAP**, the official replacement for WHOIS. Most domain endings have it, including .com,
  .net, .org, .uk, .ai, .app, .dev, .ca, .au, .fr and most newer endings. Some country endings, including .io, .co, .de, .us, .me
  and .jp, don't publish RDAP yet. For those, the row says so in `rdapNote` and the SSL and email checks still run. Their
  WHOIS services restrict automated bulk lookups, so the Actor doesn't use them.
- **DKIM** keys can only be found by guessing selector names. A missing `dkimSelectors` value doesn't prove DKIM is off,
  so it's never flagged as an issue.
- Subdomains (`shop.example.co.uk`) are checked as given for SSL and email, and their registered domain (`example.co.uk`)
  is used for expiry. A subdomain without its own DMARC record is covered by its parent's (as mail servers do), and
  `dmarcFrom` shows which domain the policy came from.
- Registry servers are queried at most two at a time each, with back-off if they ask us to slow down.

### FAQ

**How do I check when a domain expires?** Paste it and read `expiryDate` and `domainDaysLeft`. The date comes from
the registry's own RDAP server.

**How do I check SSL certificate expiry for many sites?** Paste the domains. `sslExpiryDate`, `sslDaysLeft` and
`sslValid` are in every row. Expired and misconfigured certificates are reported with the reason.

**How do I check DMARC and SPF in bulk?** Paste your domains and filter by `dmarcPolicy` or the `issues` column.

**What will my first run cost?** The pre-filled 3 domains cost less than 1 cent. After that it's $0.002 per domain
checked plus $0.0005 per run, and nothing else. There is no monthly fee for this Actor.

**Do I need an API key or a credit card?** No. A free Apify account is enough, and it includes $5 of usage a month.

**What does `critical` mean?** Act now: the domain or certificate has expired or expires within 7 days, the
certificate is broken (wrong name, self-signed), or SPF allows anyone to send (`+all`). `warning` means something to
fix soon, like a DMARC policy of `p=none` or an expiry inside your warning window.

**Is it legal?** The Actor uses public, documented services: the IANA RDAP directory and registry RDAP servers, public
DNS-over-HTTPS resolvers, and a standard TLS connection. It doesn't crawl web pages, and it doesn't collect personal data:
registrant contact details aren't stored.

**Something broke?** Open an issue on the **Issues** tab.

### Related Actors

- [Website Tech Stack Detector](https://apify.com/zahidthani/website-tech-stack-detector): CMS, e-commerce platform, analytics, hosting and email provider for any list of domains.
- [Sitemap URL Extractor & Broken Link Checker](https://apify.com/zahidthani/sitemap-url-extractor-status-checker): every URL in a site's sitemaps, with 404 and redirect checks.
- [App Store & Google Play Scraper](https://apify.com/zahidthani/app-store-google-play-scraper): app details, keyword search ranks and top charts in both stores.

### Want it done for you?

This Actor is built and maintained by [Zahid Gulgee Thani](https://zahidgulgeethani.com/). If you would rather not run it yourself, I can set up scheduled exports into Google Sheets or Excel, a dashboard, or a custom scraper for your use case. Free how-to guides and ways to get in touch are on [zahidgulgeethani.com](https://zahidgulgeethani.com/).

# Actor input Schema

## `domains` (type: `array`):

One per line: a domain (example.com), a URL or a work email address (its domain is used). Duplicates are removed.

## `expiryWarningDays` (type: `integer`):

Domains and SSL certificates expiring within this many days get a warning (7 days or less is critical).

## `onlyIssues` (type: `boolean`):

Skip healthy domains in the results, so a scheduled run only lists what needs attention. Every domain is still checked and charged.

## `checkRegistration` (type: `boolean`):

Registrar, created and expiry dates, domain status (e.g. pending delete) and DNSSEC from the registry's official RDAP service.

## `checkSsl` (type: `boolean`):

Connect on port 443 (the domain, then www.) and read the certificate: valid or not, issuer, expiry date, TLS version.

## `checkEmailDns` (type: `boolean`):

Mail servers and provider, SPF record and common mistakes, DMARC record and policy.

## `checkDkim` (type: `boolean`):

Try common DKIM selectors (google, selector1, selector2, k1, s1...). DKIM selectors can't be listed, so a missing one isn't flagged as an issue.

## `maxConcurrency` (type: `integer`):

How many domains are checked at once. Registry servers are queried at most 2 at a time each, whatever this is set to.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "wikipedia.org",
    "bbc.co.uk"
  ],
  "expiryWarningDays": 30,
  "onlyIssues": false,
  "checkRegistration": true,
  "checkSsl": true,
  "checkEmailDns": true,
  "checkDkim": true,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "apify.com",
        "wikipedia.org",
        "bbc.co.uk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zahidthani/domain-health-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "domains": [
        "apify.com",
        "wikipedia.org",
        "bbc.co.uk",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zahidthani/domain-health-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "apify.com",
    "wikipedia.org",
    "bbc.co.uk"
  ]
}' |
apify call zahidthani/domain-health-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zahidthani/domain-health-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/k1Wp6mVOe8A5fMESS/builds/t968fmgcAdO9LYT5a/openapi.json
