# Domain Intelligence (MCP) (`scrap_them_all/domain-intelligence-mcp`) Actor

MCP-friendly Apify Actor returning a structured domain intelligence card. Four modes: whois (registrar+age via RDAP), dns (A/MX/TXT/SPF/DMARC/NS), ssl (cert chain+expiry), full (all three). Universal sales/security/devops/KYC use case.

- **URL**: https://apify.com/scrap\_them\_all/domain-intelligence-mcp.md
- **Developed by:** [scrap\_them\_all](https://apify.com/scrap_them_all) (community)
- **Categories:** AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 domain intelligence cards

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 (MCP)

### What does Domain Intelligence do?

Pass any domain or URL and get back a structured intelligence card: WHOIS (registrar, age, expiration), DNS (A/MX/TXT/SPF/DMARC/NS), SSL cert chain (issuer, validity, SANs), plus inferred mail provider and hosting fingerprint, plus a deterministic LLM-ready markdown report. Designed to be **called from an MCP agent loop** for sales recon, security DD, KYC enrichment, or domain monitoring.

> Built on public RDAP, native DNS, and direct TLS handshakes. **Zero API keys, zero auth, zero proxies needed.** Highest-margin actor in the portfolio.

### Why use it from an AI agent?

- **Sub-second runs** for the typical case (full mode usually 1-3s).
- **Universal one-call coverage** - identity + email posture + hosting + SSL health in a single response.
- **Zero credentials** - no Reddit/GitHub-style PAT, no API keys to manage.
- **Mail provider detection** - infers Google Workspace / Microsoft 365 / Zoho / Fastmail / Proton / etc. from MX records.
- **Hosting fingerprint** - identifies Cloudflare / AWS Route 53 / Vercel / Netlify / OVH / etc. from NS records.
- **Standby HTTP server** - true MCP-over-HTTP endpoint with one-shot fallback.

### Modes

| Mode | What it returns | When to use |
| --- | --- | --- |
| `full` (default) | WHOIS + DNS + SSL combined | Default for any unknown domain |
| `whois` | Registrar / age / expiration / nameservers / DNSSEC only | Domain age verification, KYC checks |
| `dns` | A / AAAA / MX / NS / TXT / SPF / DMARC / CAA | Email deliverability audits, mail provider detection |
| `ssl` | TLS cert chain, issuer, expiry, SANs | SSL monitoring, cert rotation alerts |

```json
{ "domain": "anthropic.com" }
```

```json
{ "domain": "stripe.com", "mode": "dns" }
```

```json
{ "domain": "https://www.openai.com/research", "mode": "ssl" }
```

### Output (full mode)

```json
{
    "meta": {
        "domain": "anthropic.com",
        "apexDomain": "anthropic.com",
        "mode": "full",
        "scrapedAt": "2026-05-08T15:00:00Z",
        "registrar": "MarkMonitor Inc.",
        "ageDays": 3520,
        "mailProvider": "Google Workspace",
        "sslIssuer": "Google Trust Services",
        "sslExpiresInDays": 67
    },
    "intelligence": {
        "registrar": "MarkMonitor Inc.",
        "registrarUrl": "https://www.markmonitor.com",
        "registrationDate": "2016-04-25T00:00:00Z",
        "expirationDate": "2027-04-25T00:00:00Z",
        "ageDays": 3520,
        "daysUntilExpiry": 720,
        "statuses": ["client transfer prohibited"],
        "nameservers": ["ada.ns.cloudflare.com", "bob.ns.cloudflare.com"],
        "dnssec": false,
        "mailProvider": "Google Workspace",
        "mailProviderConfidence": "high",
        "spfPresent": true,
        "dmarcPresent": true,
        "dmarcPolicy": "reject",
        "hostingFingerprint": "Cloudflare",
        "sslIssuer": "Google Trust Services",
        "sslExpiresInDays": 67,
        "sslValid": true,
        "sslSans": ["anthropic.com", "*.anthropic.com"],
        "sslSelfSigned": false
    },
    "whois": { "rdap": { "...": "..." } },
    "dns": { "a": [...], "mx": [...], "spf": "v=spf1 include:_spf.google.com ~all", "...": "..." },
    "ssl": { "leaf": { "...": "..." }, "chain": [ "..." ] },
    "llm_ready": {
        "summary": "anthropic.com: 9.6y old (registered 2016-04-25), registered via MarkMonitor Inc., DNS hosted on Cloudflare, mail via Google Workspace, SSL valid (issued by Google Trust Services, expires in 67d), SPF present, DMARC reject.",
        "markdown_report": "## Domain Intelligence Report\n..."
    }
}
```

### Detection coverage

**Mail providers (12+):** Google Workspace, Microsoft 365, Zoho, Proton, Fastmail, Amazon SES, Mailgun, SendGrid, OVH, Mailjet, Postmark, iCloud.

**Hosting fingerprints (12+):** Cloudflare, AWS Route 53, Google Cloud DNS, Vercel, Netlify, OVH, GoDaddy, Gandi, Namecheap, DigitalOcean, Azure DNS, Hetzner.

### Pricing (PPE)

| Mode | Price per call |
| --- | --- |
| All modes | $0.001 actor start + $0.005 intelligence card = **$0.006/call** |

### Sources

- **RDAP** (`data.iana.org/rdap/dns.json` bootstrap + per-TLD RDAP servers) - the modern JSON-based replacement for legacy WHOIS. Operated by registrars / TLD operators directly.
- **DNS** - native Node `dns/promises` resolver against your container's DNS server.
- **TLS** - direct handshake via `tls.connect`, peer cert chain inspected.

### Limits

- **Legacy ccTLD WHOIS** - some older ccTLDs (.de, .it, etc.) only expose data via legacy port-43 WHOIS, not RDAP. The Actor returns `rdap_tld_not_supported` for those.
- **Multi-label TLD detection** (e.g. `.co.uk`) uses a curated list, not the full Public Suffix List. Common cases work, exotic ones may misclassify the apex.
- **DNS resolver** depends on the container's resolver (typically Apify cloud's). For 100% reproducibility against an authoritative server, query the relevant NS directly.

### Calling from an MCP agent

The Apify MCP server (`mcp.apify.com`) exposes this Actor as the tool `call-actor` with name `domain-intelligence-mcp`. Direct Standby HTTP:

```bash
curl -X POST -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -d '{"domain":"anthropic.com"}' \
  https://<actor-standby-url>
```

### Pairs naturally with

- `web-company-intelligence-mcp` for full company web fingerprint (tech stack + identity + this actor's domain card)
- `fr-company-intelligence-mcp` for French registry data on the same domain
- `github-org-intelligence-mcp` if the domain belongs to an open-source org

# Actor input Schema

## `domain` (type: `string`):

Domain like 'anthropic.com' or full URL 'https://www.anthropic.com/research'. The hostname is extracted automatically; subdomain is normalized to the apex domain for WHOIS but kept as-is for DNS+SSL.

## `mode` (type: `string`):

Pick a single subset to lower latency, or 'full' for the complete card.

## `includeRawWhois` (type: `boolean`):

Add the unmodified RDAP response under rawRdap (debug only).

## `includeRawCert` (type: `boolean`):

Add the full PEM-encoded cert chain (debug only).

## Actor input object example

```json
{
  "domain": "anthropic.com",
  "mode": "full",
  "includeRawWhois": false,
  "includeRawCert": false
}
```

# Actor output Schema

## `card` (type: `string`):

No description

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrap_them_all/domain-intelligence-mcp").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrap_them_all/domain-intelligence-mcp").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 '{}' |
apify call scrap_them_all/domain-intelligence-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5CieaAbamTgEpDPU5/builds/eiMk3xuaYSbGQEt5H/openapi.json