# Domain WHOIS, DNS, Email & SSL Checker (`subimpact/domain-intel`) Actor

Domain intelligence in one row per domain: WHOIS via RDAP (registrar, created, expiry), DNS records, SPF and DMARC, email provider, HTTPS status and TLS certificate expiry, plus availability. No API key. $0.50 per 1,000 domains, no start fee.

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

## Pricing

from $0.35 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Intelligence API — WHOIS, DNS, SSL & Email Security

**One row per domain.** Registration data from RDAP WHOIS, DNS records, SPF/DMARC email
authentication, the mail provider behind the MX records, and the HTTPS + TLS certificate state —
all keyless, plain HTTP, no browser, no proxy setup. Paste domains, hostnames or full URLs and get
clean JSON.

- **No start fee. $0.50 per 1,000 domains** ($0.0005 per domain checked).
- Up to **10,000 domains per run**, 5 checked in parallel by default.
- Every check is optional (`checks` input). Default run checks all five.

### What you get

| Area | Fields |
| --- | --- |
| Registration (RDAP WHOIS) | `available`, `availabilityConfidence`, `registrar`, `createdAt`, `updatedAt`, `expiresAt`, `daysToExpiry`, `statusCodes`, `nameservers` |
| DNS | `a`, `aaaa`, `mx`, `ns`, `txt`, `caa` |
| Email authentication | `spf`, `spfRecord`, `dmarc`, `dmarcRecord`, `dmarcPolicy`, `emailProvider` |
| HTTPS / TLS | `httpsOk`, `finalUrl`, `httpStatus`, `redirectsToWww`, `tlsIssuer`, `tlsValidTo`, `tlsDaysLeft`, `tlsAuthorized` |
| Run | `errors` (per check), `checkedAt`, `status` (`ok`, `partial`, `error`) |

### Input

```json
{
  "domains": [
    "apify.com",
    "https://www.example.co.uk/pricing?plan=pro",
    "github.com"
  ],
  "checks": ["whois", "dns", "email", "tls", "http"],
  "concurrency": 5,
  "maxDomains": 100
}
```

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `domains` | array | — (required) | Domains, hostnames or URLs. URLs are reduced to their registrable domain, `www.` is dropped, IDNs are converted to punycode, duplicates are removed. |
| `checks` | array | all five | Any of `whois`, `dns`, `email`, `tls`, `http`. Unknown values are ignored and reported in the log. |
| `concurrency` | integer | `5` | Domains checked in parallel, 1–20. RDAP lookups are additionally paced at one request per second (registries rate-limit hard). |
| `maxDomains` | integer | `100` | Row cap for the run, 1–10,000. Default 100 keeps a first run at a few cents. |

### Output

One dataset item per domain. This is a real row from a live run (a couple of long `aaaa`/`txt`
entries are trimmed here; the dataset holds them all):

```json
{
  "domain": "apify.com",
  "available": false,
  "availabilityConfidence": "high",
  "registrar": "Amazon Registrar, Inc.",
  "createdAt": "2009-06-02T17:14:10.000Z",
  "updatedAt": "2026-05-16T16:53:04.000Z",
  "expiresAt": "2035-06-02T17:14:10.000Z",
  "daysToExpiry": 3121,
  "statusCodes": ["client transfer prohibited"],
  "nameservers": [
    "ns-1225.awsdns-25.org",
    "ns-1928.awsdns-49.co.uk",
    "ns-449.awsdns-56.com",
    "ns-839.awsdns-40.net"
  ],
  "a": ["18.66.102.115", "18.66.102.61", "18.66.102.102", "18.66.102.34"],
  "aaaa": ["2600:9000:223c:1200:9:a03e:6540:93a1", "2600:9000:223c:f200:9:a03e:6540:93a1"],
  "mx": [
    { "priority": 1, "host": "aspmx.l.google.com" },
    { "priority": 5, "host": "alt1.aspmx.l.google.com" },
    { "priority": 5, "host": "alt2.aspmx.l.google.com" },
    { "priority": 10, "host": "aspmx2.googlemail.com" },
    { "priority": 10, "host": "aspmx3.googlemail.com" }
  ],
  "ns": ["ns-449.awsdns-56.com", "ns-1225.awsdns-25.org", "ns-1928.awsdns-49.co.uk", "ns-839.awsdns-40.net"],
  "txt": [
    "v=spf1 a mx include:_spf.google.com include:mailgun.org include:amazonses.com include:19497222.spf05.hubspotemail.net -all",
    "v=MCPv1; k=ed25519; p=1rDnoEigwTr+4JjG89+sLbdNnswCnLjmaeT34srW53Y="
  ],
  "caa": [
    "0 issue \"digicert.com\"",
    "0 issue \"amazonaws.com\"",
    "0 issue \"letsencrypt.org\"",
    "0 issuewild \"letsencrypt.org\"",
    "0 issuewild \"amazonaws.com\""
  ],
  "spf": true,
  "spfRecord": "v=spf1 a mx include:_spf.google.com include:mailgun.org include:amazonses.com include:19497222.spf05.hubspotemail.net -all",
  "dmarc": true,
  "dmarcRecord": "v=DMARC1; p=reject; sp=reject; pct=100; rua=mailto:dmarc-reports@apify.com; ri=604800",
  "dmarcPolicy": "reject",
  "emailProvider": "Google Workspace",
  "httpsOk": true,
  "finalUrl": "https://apify.com/",
  "httpStatus": 200,
  "tlsIssuer": "Amazon — Amazon RSA 2048 M04",
  "tlsValidTo": "2027-01-16T23:59:59.000Z",
  "tlsDaysLeft": 62,
  "tlsAuthorized": true,
  "redirectsToWww": false,
  "errors": null,
  "checkedAt": "2026-11-15T08:45:46.167Z",
  "status": "ok"
}
```

#### Field notes

- **`available` / `availabilityConfidence`** — `available: true` means the registry's RDAP server
  answered 404 for the name. `availabilityConfidence` is `high` when DNS also says NXDOMAIN,
  `medium` when DNS was not checked or failed, and `low` when the name still resolves — a cached or
  stale delegation, so verify before you buy. `available` is `null` when the TLD publishes no RDAP
  service or the lookup failed; those rows carry `errors.whois` and are billed as `partial`.
- **`null` vs `[]`** — an empty array means "the query succeeded and the record does not exist"
  (e.g. `caa: []` = any CA may issue). `null` means "not checked or the lookup failed"; the reason is
  in `errors`.
- **`mx`** — `[{priority, host}]`, sorted by priority. A null MX (`0 .`) comes back as
  `host: null` with `emailProvider: "Null MX (no mail)"`: the domain explicitly accepts no email.
- **`emailProvider`** — guessed from the MX hostnames (Google Workspace, Microsoft 365, Zoho,
  Proofpoint, Mimecast, Barracuda, Amazon SES, Mailgun, SendGrid, Fastmail, iCloud, Yandex,
  GoDaddy, …). `Other` when the provider is not recognised.
- **`tlsIssuer` / `tlsValidTo` / `tlsDaysLeft` / `tlsAuthorized`** — read from a direct TLS handshake
  on port 443. The certificate is reported even when it is invalid; `tlsAuthorized: false` means
  Node's TLS stack rejected it (self-signed, expired, wrong hostname, unknown CA).
- **`httpsOk`** — `true` when `https://<domain>/` answered with a 2xx or 3xx after redirects.
  `httpStatus` and `finalUrl` are reported for 4xx/5xx answers as well, so a reachable-but-broken
  site is still visible.
- **`daysToExpiry` / `tlsDaysLeft`** — whole days from `checkedAt`; negative means already expired.
- **`status`** — `ok` when every enabled check succeeded, `partial` when at least one failed but the
  row still carries data, `error` when every check failed. `ok` and `partial` rows are billed;
  `error` rows (and invalid input entries) are delivered for free.

### Pricing

**$0.50 per 1,000 domains** — $0.0005 per domain checked, no start fee, no monthly fee.
A run of 100 domains costs $0.05; 10,000 domains cost $5.00. You are only charged for rows that
delivered at least one successful check: failed lookups and invalid input entries are free.
Billing is pay-per-event (`domain-checked`), so you pay for what the run actually delivered.

### How it works

- **WHOIS** — `https://rdap.org/domain/<domain>`, which redirects to the registry's own RDAP server
  (Verisign, PIR, Nominet, …). One keyless request per domain. Registry RDAP servers rate-limit
  aggressively, so requests are paced at one per second and retried with the registry's own
  `Retry-After`; the rest of the checks run in parallel meanwhile.
- **DNS** — Google Public DNS over HTTPS (`https://dns.google/resolve`), record types A, AAAA, MX,
  NS, TXT and CAA, plus a DMARC TXT lookup at `_dmarc.<domain>`. No resolver configuration needed.
- **Email** — SPF record found in TXT, DMARC record and `p=` policy, mail provider from MX hosts.
- **HTTPS/TLS** — one `GET https://<domain>/` (redirects followed, body discarded) and one raw TLS
  handshake for the certificate, 10–15 s timeouts.

### Tips and limits

- Start with the default `maxDomains: 100`; raise it for bulk runs. `maxDomains` counts delivered
  rows, and the run stops cleanly if the platform's max-charge limit is reached.
- Checking 10,000 domains with WHOIS takes a while (roughly one RDAP request per second). If you
  only need DNS/SSL/email data, pass `"checks": ["dns", "email", "tls", "http"]` — that skips RDAP
  entirely and runs much faster.
- `email` needs MX and TXT records; the actor fetches them once and shares them with `dns`.
- Registrable-domain detection covers the common multi-label public suffixes (`co.uk`, `com.au`,
  `com.my`, `co.jp`, `com.br`, …). Private suffixes such as `*.github.io` are reduced to their
  parent (`github.io`), which is what RDAP can answer for.
- No proxy is used: requests come from the Apify platform's IPs. A site that blocks datacenter
  traffic shows `httpsOk: false` with the reason in `errors.http`; its WHOIS, DNS and TLS data are
  still returned.
- Some TLDs (e.g. `.io`) publish no RDAP service. Those rows have `available: null` and an
  `errors.whois` note — the actor never guesses availability from a missing RDAP server.

### Use cases

- Domain portfolio monitoring: expiry dates, registrar, status codes and certificate expiry in one
  scheduled run, with Slack/CRM webhooks on the run.
- Lead qualification: does this company own its domain, does it accept mail, does it have a working
  site and a valid certificate?
- Vendor / security checks: DMARC policy, SPF coverage, CAA restrictions, TLS issuer.
- Domain research: expiry-based prospecting, unregistered-domain screening.

### Support

Found a response that parses badly? Open an issue on the actor's Apify page with the domain and the
run ID — the `RUN_SUMMARY` key-value record (counts, caps, warnings) is there to help.

### Run monitoring and privacy

If a run fails or times out, this Actor tells its developer the run ID and status, so we can fix problems fast. It never sends your input, your results or your account data.

# Actor input Schema

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

Domains, hostnames or URLs to check. URLs are reduced to their registrable domain (https://www.example.co.uk/pricing?x=1 -> example.co.uk), and duplicates are removed. Up to 10,000 per run.

## `checks` (type: `array`):

Which checks to run. Allowed values: whois (RDAP registration data), dns (A, AAAA, MX, NS, TXT, CAA records), email (SPF, DMARC and mail-provider guess), tls (certificate issuer and expiry) and http (HTTPS reachability, final URL). Default: all five. Unknown values are ignored; DNS answers needed by 'email' are fetched once and shared with 'dns'.

## `concurrency` (type: `integer`):

How many domains are checked in parallel (1-20). Higher is faster but more likely to hit RDAP or DNS rate limits.

## `maxDomains` (type: `integer`):

Maximum number of rows delivered in one run (1-10,000). Default 100 keeps a default run at a few cents. Invalid input entries are delivered as free error rows after the checked domains.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "example.com",
    "stripe.com"
  ],
  "checks": [
    "whois",
    "dns",
    "email",
    "tls",
    "http"
  ],
  "concurrency": 5,
  "maxDomains": 100
}
```

# Actor output Schema

## `domains` (type: `string`):

One row per domain: availability (RDAP 404 + DNS cross-check), registrar, creation/update/expiry dates and daysToExpiry, EPP status codes, registry nameservers, A/AAAA/MX/NS/TXT/CAA records, SPF and DMARC with policy, mail provider, HTTPS status and final URL, TLS issuer/expiry/days left, per-check errors and a status of ok, partial or error.

# 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",
        "example.com",
        "stripe.com"
    ],
    "maxDomains": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/domain-intel").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",
        "example.com",
        "stripe.com",
    ],
    "maxDomains": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("subimpact/domain-intel").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",
    "example.com",
    "stripe.com"
  ],
  "maxDomains": 100
}' |
apify call subimpact/domain-intel --silent --output-dataset

```

## MCP server setup

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

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/3WyT9wcaYDF2fG6cc/builds/XVXYxe1lFAYZ3EiII/openapi.json
