# Domain Intelligence Suite: WHOIS, DNS, SSL, Tech Stack & More (`shipsatnight/domain-intelligence-suite`) Actor

Bulk domain enrichment in one call: WHOIS/RDAP, DNS, SSL, tech stack, subdomains, Wayback history, email checks, and social links. Nine modules, pay only for what you use. No headless browser, no proxy costs.

- **URL**: https://apify.com/shipsatnight/domain-intelligence-suite.md
- **Developed by:** [Donovan](https://apify.com/shipsatnight) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Domain Intelligence Suite

Bulk domain enrichment in one call: **WHOIS/RDAP, DNS, SSL certificates, tech-stack fingerprinting, HTTP headers, subdomain enumeration, Wayback Machine history, email deliverability, and social links.**

Built for sales teams enriching leads, security researchers, competitive intel, domain investors, and brand-protection teams.

### What sets this apart

There are several domain-enrichment actors on the store — this isn't an uncontested category. Most cover WHOIS + DNS, a couple add SSL or tech-stack detection. None combine all nine modules in one call with per-module pricing, so you pay only for what you actually use:

- **Nine modules, one request per domain.** WHOIS, DNS, SSL, tech stack, HTTP headers, subdomains, Wayback history, email deliverability, and social links — pick any subset per run.
- **Pure HTTP/DNS, no headless browser.** Every module is a protocol-level call (RDAP, DNS-over-HTTPS, a raw TLS handshake, certificate-transparency search) — no Playwright, no proxy costs, low compute, high margin, and nothing that breaks when a site changes its frontend markup.
- **Modules fail independently.** If one module can't complete for a domain (a flaky upstream service, a blocked port), that domain's report still ships with every other module's data intact and the failure listed in `modules_failed` — one bad module never blanks the whole record.
- **Honest about what's actually free.** Some competing tools and research docs describe a "favicon → company name" enrichment step; that's a commercial product (Clearbit and similar), not something derivable for free. This actor doesn't claim it. The social-links module is scoped to what it actually does: reading known link patterns off the domain's own homepage.

### Modules

| Module | What it returns | Notes |
|---|---|---|
| `whois` | Registrar, creation/expiry dates, domain age, nameservers, status codes | Via RDAP, the modern JSON/HTTP standard — not raw WHOIS-over-port-43 |
| `dns` | A, AAAA, MX, TXT, NS, CNAME records | Via DNS-over-HTTPS |
| `ssl` | Certificate issuer, validity window, SAN entries (reveals related domains), wildcard flag | Real TLS handshake, not a third-party lookup API |
| `tech_stack` | CDN, analytics tools, and frameworks detected | Pattern-matched from the page already fetched for `http_headers`/`social`. Covers common, high-confidence signals — not a claim of full Wappalyzer-level fingerprint coverage |
| `http_headers` | Status code, server header, HSTS presence, response time | |
| `email_check` | Whether MX records exist, and whether the top mail host accepts an SMTP connection | Never sends mail. **Confirmed on Apify's own platform: outbound port 25 is blocked**, so `smtp_connectable` will always be `null` in production — this module currently only delivers `mx_found` there. Kept in because MX presence is still real signal, and the code fails soft rather than misreporting `false`. |
| `subdomains` | Subdomains found via certificate transparency logs | Best-effort. The underlying free service (crt.sh) is community-run and occasionally overloaded; a degraded run returns `source_degraded: true` with an empty list rather than failing the domain |
| `wayback` | Earliest known snapshot date | Via the Internet Archive's CDX API |
| `social` | Twitter/X, LinkedIn, and GitHub links found on the homepage | Only what's actually linked from the page — not a brand-matching guess |

### Input

```json
{
  "domains": ["stripe.com", "ramp.com"],
  "modules": ["whois", "dns", "ssl", "tech_stack", "http_headers"]
}
```

| Field | Type | Default | What it does |
|---|---|---|---|
| `domains` | string\[] | required | Bare hostnames or full URLs (path ignored). Duplicates removed automatically. |
| `modules` | string\[] | `["whois","dns","ssl","tech_stack","http_headers"]` | Which modules to run. Omit a module to skip its cost entirely. |

### Output

One record per domain in the default dataset:

```json
{
  "domain": "stripe.com",
  "resolved_at": "2026-08-03T20:00:00.000Z",
  "whois": { "registrar": "SafeNames Ltd.", "created_at": "1995-09-12T04:00:00.000Z", "age_days": 11283, "expires_at": "2027-09-11T04:00:00.000Z", "nameservers": ["ns-1087.awsdns-07.org"], "status": ["clientTransferProhibited"] },
  "dns": { "a": ["198.202.176.231"], "aaaa": [], "mx": [{ "priority": 10, "host": "aspmx.l.google.com" }], "txt": ["v=spf1 include:_spf.google.com ~all"], "ns": ["ns-1087.awsdns-07.org"], "cname": [] },
  "ssl": { "issuer": "DigiCert Inc DigiCert Global G3 TLS ECC SHA384 2020 CA1", "valid_from": "2026-07-28T00:00:00.000Z", "valid_to": "2026-11-12T23:59:59.000Z", "san": ["stripe.com", "www.stripe.com"], "wildcard": false },
  "tech_stack": { "cdn": [], "analytics": ["Google Analytics"], "frameworks": ["React"], "server": null },
  "http_headers": { "status": 200, "server": null, "x_powered_by": null, "strict_transport_security": true, "response_time_ms": 142 },
  "modules_failed": []
}
```

A run-level summary (domains processed, module charges issued, per-domain failures, whether the run stopped early on a spending cap) is written to the key-value store under `RUN_SUMMARY`.

### Pricing

Pay-per-event: $0.00005 actor start, $0.0005 per domain attempted, $0.001 per module that successfully completes. A 5-module default run costs about $0.0056/domain; the full 9-module set costs about $0.0096/domain. You're only charged for modules that actually returned data — a module that fails for a given domain isn't billed.

### Status

Built, pushed, monetized, and published to the Apify Store.

# Actor input Schema

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

Bare hostnames or full URLs, e.g. "stripe.com" or "https://stripe.com/pricing" (path is ignored). Duplicates are removed automatically.

## `modules` (type: `array`):

Which enrichment modules to run per domain. Fewer modules means faster runs and lower cost. Defaults to whois, dns, ssl, tech\_stack, and http\_headers.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "ramp.com"
  ],
  "modules": [
    "whois",
    "dns",
    "ssl",
    "tech_stack",
    "http_headers"
  ]
}
```

# Actor output Schema

## `domainReports` (type: `string`):

One record per domain, with a nested result for each requested module and a modules\_failed list for any that couldn't be completed.

## `runSummary` (type: `string`):

Counts of domains processed, module charges issued, per-domain module failures, and charge-limit status for this run.

# 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": [
        "stripe.com",
        "ramp.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("shipsatnight/domain-intelligence-suite").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": [
        "stripe.com",
        "ramp.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("shipsatnight/domain-intelligence-suite").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "stripe.com",
    "ramp.com"
  ]
}' |
apify call shipsatnight/domain-intelligence-suite --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shipsatnight/domain-intelligence-suite",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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