# Domain Intelligence: DNS, WHOIS/RDAP, SSL and Tech Stack (`tan-solutions/domain-intel`) Actor

Check up to 1,000 domains at once: DNS records, SPF/DMARC/DKIM email security, registration data from RDAP (registrar, dates, status; personal contacts always hidden), security headers grade, TLS certificate and technologies. Non-existent, invalid and duplicate domains are free.

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

## Pricing

from $1.25 / 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: DNS, WHOIS/RDAP and SSL

Check up to 1,000 domains at once: DNS, WHOIS/RDAP and SSL. Paste a list of domains and get one clear row per domain: where it points, who handles its email, whether SPF, DMARC
and DKIM are set up, when it was registered and when it expires, how good its security headers are, who issued its
SSL certificate, plus the main technologies the website uses. Domains that do not exist cost nothing.

### Run it from the API or on a schedule

Get one row per domain back in one call (replace `<YOUR_API_TOKEN>` with your Apify API token from Console, **Settings**, **API & Integrations**):

```bash
curl -X POST "https://api.apify.com/v2/acts/tan-solutions~domain-intel/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"domains":["apify.com","example.com"]}'
```

Send `{}` (no input) to try it on example.com.

Check the same domains every Monday at 06:00 UTC (for example, to catch expiring certificates and domains) with an Apify schedule (`hURf1EYMO4QLVyL0n` is this Actor's ID):

```bash
curl -X POST "https://api.apify.com/v2/schedules?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"name": "domain-intel-weekly", "cronExpression": "0 6 * * 1", "timezone": "UTC", "isEnabled": true, "isExclusive": true,
       "actions": [{"type": "RUN_ACTOR", "actorId": "hURf1EYMO4QLVyL0n",
         "runInput": {"body": "{\"domains\":[\"apify.com\",\"example.com\"]}", "contentType": "application/json"}}]}'
```

In Apify Console the same is: **Schedules**, **Create new**, cron `0 6 * * 1`, add this Actor with your input.

### What it does

For each domain you give it, the Actor:

- **Looks up DNS**: A, AAAA, CNAME, MX, NS, TXT, CAA and SOA records, through DNS over HTTPS.
- **Checks email security**: the SPF record, the DMARC policy (none, quarantine or reject) and DKIM keys for common
  selectors (or the selectors you list). It also names the mail provider when the MX records make it clear.
- **Reads registration data (RDAP, the modern replacement for WHOIS)**: registrar (and its abuse contact), created,
  updated and expiry dates, status codes, name servers and DNSSEC. Personal contact details are never returned, not
  even when the registry shows them.
- **Opens the homepage once**: HTTP status, redirects, HTTPS, a security headers grade from A to F, the TLS
  certificate (issuer, valid until, days left) and the technologies it can see (CMS, frameworks, analytics, CDN).
  It reads robots.txt first and skips the homepage when robots.txt says no.

You can give plain domains or full URLs (the host is used). Duplicates and entries that are not domain names are
skipped for free and listed in the run summary.

### Who it is for

- IT, security and email teams who check SPF, DMARC, certificates and security headers across many domains.
- Agencies and analysts who need the registrar, expiry dates and tech stack of a list of websites.
- Developers and AI agents that want clean domain facts from one API call.

### Quick start

1. Add your domains in **Domains**, one per line (up to 1,000).
2. Click **Start**. One domain takes a few seconds; 100 `.com` domains take about 6 minutes.
3. Open the **Output** tab: one row per domain. Download it as JSON, CSV or Excel, or read it through the API.

Left empty, the Actor checks example.com as a quick demo.

### Input

| Field | Required | What it is |
| --- | --- | --- |
| `domains` | yes | Domains or URLs, one per entry. At most 1,000 per run. |
| `maxDomains` | no | Cap on domains per run (default 100, at most 1,000). Domains over the cap are skipped for free. |
| `checkDns` | no | DNS records and email security (SPF, DMARC, DKIM). On by default. |
| `checkRdap` | no | Registration data from RDAP. On by default. |
| `checkWebsite` | no | Open the homepage once: headers, TLS certificate and technologies. On by default; turn it off for a faster run. |
| `followRegistrarRdap` | no | Also ask the registrar's own RDAP server for more detail. Off by default. |
| `dkimSelectors` | no | Your own DKIM selectors to check (up to 10). Empty = 8 common ones. |
| `timeoutSecs` | no | Timeout per request, 5 to 60 seconds (default 20). |
| `maxConcurrency` | no | Domains checked at the same time, 1 to 8 (default 4). |

Example:

```json
{
  "domains": ["apify.com", "wikipedia.org", "https://www.bbc.co.uk/news"],
  "checkWebsite": true,
  "dkimSelectors": ["google", "selector1"]
}
```

### Output example

A real row from a run on 13 Nov 2026 (shortened: the full row also has the raw `dns`, `mail`, `rdap` and `website`
sections and all IP addresses):

```json
{
  "domain": "apify.com",
  "input": "apify.com",
  "registrableDomain": "apify.com",
  "publicSuffix": "com",
  "checkedAt": "2026-11-13T13:25:57.222Z",
  "registrar": "Amazon Registrar, Inc.",
  "createdAt": "2009-06-02T17:14:10Z",
  "expiresAt": "2035-06-02T17:14:10Z",
  "ipAddresses": ["3.170.42.100", "3.170.42.109", "2600:9000:2870:2600:9:a03e:6540:93a1"],
  "mailProvider": "Google Workspace",
  "spf": true,
  "dmarcPolicy": "reject",
  "httpStatus": 200,
  "securityGrade": "C",
  "tlsIssuer": "Amazon",
  "tlsDaysToExpiry": 64,
  "technologies": ["Amazon CloudFront", "React", "Intercom", "HubSpot", "Google Tag Manager", "Bootstrap", "Next.js"]
}
```

The Output tab has three views: **Domain results** (the overview above), **Email security** (SPF, DMARC and DKIM in
detail) and the **run summary** (the key-value record `SUMMARY`: skipped, invalid and not-found domains with the reason).

#### Email security fields

The checks follow the current standards: SPF as in RFC 7208 and DMARC as in RFC 9989 (May 2026, which replaces RFC 7489).

- `mail.spf.dnsLookups`: DNS lookups that the domain's own SPF record asks for.
- `mail.spf.dnsLookupsTotal`: the same count, followed through every `include:` and `redirect=` target, the way mail
  servers count it (RFC 7208, section 4.6.4). Counting stops once it passes 10.
- `mail.spf.lookupLimitExceeded`: `true` when that total passes 10. Mail servers then fail the SPF check (permerror),
  and `mail.spf.valid` is `false`.
- `mail.spf.voidLookups`: lookups for `a`, `mx`, `exists`, `include:` and `redirect=` names that came back empty (the
  name does not exist, or has no record of that type). More than 2 is a permerror (RFC 7208, section 4.6.4), so
  `mail.spf.valid` is `false`. Addresses are looked up as an IPv4 mail server does it (A records), so a host with only
  IPv6 addresses counts as empty.
- One `mx` term may point to at most 10 mail servers (RFC 7208, section 4.6.4). More is a permerror, named in
  `mail.spf.errors`, and `mail.spf.valid` is `false`.
- `mail.dmarc.policy`: `none`, `quarantine` or `reject`. A DMARC record without a `p=` tag counts as `none` (RFC 9989).
  Then `mail.dmarc.policyMissing` is `true` and `mail.dmarc.notes` says so.
- `mail.dmarc.pct`: still read from older records, but `pct=` is historic in RFC 9989, so new records leave it out.
- `mail.dmarc.nonExistentSubdomainPolicy`, `mail.dmarc.psd` and `mail.dmarc.testMode`: the RFC 9989 tags `np=`
  (policy for subdomains that do not exist), `psd=` (`y`, `n` or `u`: is this a public suffix domain) and `t=`
  (`true` = test mode). An invalid value is ignored with a note, like an invalid `sp=`.
- When a domain has no DMARC record of its own, the Actor finds the one that applies the way RFC 9989 does: it walks up
  the DNS tree (for example `mail.example.com`, then `example.com`, then `com`). The found record is in
  `mail.dmarc.inherited`, its domain in `mail.dmarc.policyDomain`. The walk is bounded as the RFC states: at most 4
  extra DNS queries per domain, counted in `mail.dmarc.treeWalkQueries`.
- `mail.dmarc.effectivePolicy`: the policy that applies to the domain: its own `p=`, or from the inherited record
  `sp=` (or `np=` when the domain does not exist), else `p=`. The `dmarcPolicy` column and the other `mail.dmarc`
  fields describe the domain's own record only.
- The SPF checks look up the `a`, `mx` and `exists` names of the record too, so a domain costs up to about 10 extra
  DNS queries for SPF.

### Pricing

You pay per domain delivered (the `domain` event): one row for each domain whose DNS answered or whose registration
was found. Non-existent, invalid and duplicate domains are free, and so are domains over your "Maximum domains"
setting. If your spending limit is reached, the run stops cleanly and tells you so.

| Apify plan | Price per 1,000 domains |
| --- | --- |
| Free | $2.00 |
| Bronze | $1.75 |
| Silver | $1.50 |
| Gold | $1.25 |

Each delivered row includes the registration, DNS, website and email-security checks you turned on. Apify's standard
Actor start event is charged when a run starts, at the platform's default price.

### Limits

- At most 1,000 domains per run (default cap 100).
- Registration lookups are sent at most once per second to each registry, to respect their limits. Measured on Apify:
  one `.com` lookup every 1.7 seconds, so 1,000 `.com` domains take about 30 minutes, and about an hour with the
  website check at the default speed (4 at once). A mix of endings goes faster.
- The default run timeout is 2 hours, enough for 1,000 domains. If you lower it, allow about 1 hour per 1,000
  domains with the website check (30 minutes without), or the run stops before the end.
- Some country endings have no RDAP service yet. Their rows say `unsupported_tld` in the registration section; the
  DNS, email and website parts still work.
- DKIM can only be checked for selectors that are tried. The Actor tries 8 common ones by default, or up to 10 of yours.
- One homepage request per domain. No crawling, no login, no forms, no CAPTCHA solving and no proxies.
- The website check identifies itself as
  `Mozilla/5.0 (compatible; TanForgeBot/1.0; +https://apify.com/tan-solutions)`. Site owners can allow
  or block it in robots.txt with the `TanForgeBot` token.

### FAQ

**Is this a WHOIS lookup?** It uses RDAP, the official successor of WHOIS run by the registries. It returns the same
registrar and date facts in a clean form, without personal contact data.

**Why is the registration section empty for my `.xx` domain?** That registry does not offer RDAP yet
(`unsupported_tld`). You still get DNS, email security and the website facts.

**Why was the homepage `robots_disallowed`?** The site's robots.txt asks crawlers (or TanForgeBot) not to fetch it.
The Actor respects that; the rest of the row is still filled.

**Why is DKIM "not found" when I know it is set up?** DKIM keys live under a selector name that only the sender knows.
Add your selector in "DKIM selectors".

**Can I call it from an AI agent or my own code?** Yes, through the Apify API, SDKs or MCP: pass `domains` and read
the dataset items.

### Related tools by Tan Solutions

- [URL to Markdown](https://apify.com/tan-solutions/url-to-markdown): web pages to clean Markdown for LLMs, RAG pipelines and AI agents.
- [Document to Markdown](https://apify.com/tan-solutions/document-to-markdown): PDF, Word and PowerPoint files to Markdown for LLMs and RAG.
- [SEO Audit Tool](https://apify.com/tan-solutions/seo-audit): on-page SEO checker with PageSpeed for any list of pages.
- [US Company Filings & Financials](https://apify.com/tan-solutions/company-filings): 10-K, 10-Q, 8-K filings and XBRL facts by ticker.

### More from Tan Solutions

- [Domain intel tool page](https://www.tansolutions.org/tools/domain-intel/): details and examples for this Actor on our site.
- [Guide: check SPF, DKIM and DMARC for many domains](https://www.tansolutions.org/guides/check-spf-dkim-dmarc-many-domains/)
- [All Tan Solutions data tools](https://www.tansolutions.org/tools/)

### Your responsibilities

You are responsible for lawful use of the results and must follow the terms of the registries whose data is returned
(each row names the RDAP server it came from). In particular, the data may not be used for mass unsolicited
advertising. Registrant contact data is never returned. DNS, registration and technology data can be incomplete or
wrong; the Actor is provided without warranty, and liability is capped at the fees you paid in the last 12 months.
Questions and issues are answered within 14 days through the Actor's Issues tab.

Not affiliated with ICANN, Verisign, Cloudflare, Google or Microsoft. All product names belong to their owners.

Made by Tan Solutions.

# Actor input Schema

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

One domain per line, for example example.com. Full URLs are fine: only the domain is used. Duplicates and invalid entries are skipped for free. Left out, example.com is checked as a quick demo.

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

Stop after this many domains. The hard limit is 1,000 per run.

## `checkDns` (type: `boolean`):

A, AAAA, CNAME, MX, NS, TXT, CAA and SOA records, plus SPF, DMARC and DKIM checks.

## `checkRdap` (type: `boolean`):

Registrar, creation and expiry dates, status codes, nameservers and DNSSEC from the registry. Personal contacts are always hidden.

## `checkWebsite` (type: `boolean`):

One request to the homepage (robots.txt is respected) for the security headers grade, the TLS certificate and the technologies it uses.

## `followRegistrarRdap` (type: `boolean`):

Some registries point to the registrar for more detail. Off by default; it adds one request per domain.

## `dkimSelectors` (type: `array`):

Up to 10 selector names. Leave empty for the common ones (default, google, selector1, selector2, k1, s1, mail, dkim).

## `timeoutSecs` (type: `integer`):

How long one DNS, registration or website request may take before it counts as failed.

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

Registration lookups stay at 1 per second per registry whatever this is set to.

## Actor input object example

```json
{
  "domains": [
    "example.com"
  ],
  "maxDomains": 100,
  "checkDns": true,
  "checkRdap": true,
  "checkWebsite": true,
  "followRegistrarRdap": false,
  "timeoutSecs": 20,
  "maxConcurrency": 4
}
```

# Actor output Schema

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

No description

## `emailSecurity` (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": [
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tan-solutions/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": ["example.com"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tan-solutions/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/hURf1EYMO4QLVyL0n/builds/M88UoOhWvbqLSgOhb/openapi.json
