# 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Domain Intelligence (MCP)",
        "description": "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.",
        "version": "0.1",
        "x-build-id": "eiMk3xuaYSbGQEt5H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrap_them_all~domain-intelligence-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrap_them_all-domain-intelligence-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrap_them_all~domain-intelligence-mcp/runs": {
            "post": {
                "operationId": "runs-sync-scrap_them_all-domain-intelligence-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrap_them_all~domain-intelligence-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-scrap_them_all-domain-intelligence-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domain"
                ],
                "properties": {
                    "domain": {
                        "title": "Domain or URL",
                        "minLength": 3,
                        "type": "string",
                        "description": "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": {
                        "title": "Mode",
                        "enum": [
                            "full",
                            "whois",
                            "dns",
                            "ssl"
                        ],
                        "type": "string",
                        "description": "Pick a single subset to lower latency, or 'full' for the complete card.",
                        "default": "full"
                    },
                    "includeRawWhois": {
                        "title": "Include raw RDAP JSON",
                        "type": "boolean",
                        "description": "Add the unmodified RDAP response under rawRdap (debug only).",
                        "default": false
                    },
                    "includeRawCert": {
                        "title": "Include raw SSL cert chain",
                        "type": "boolean",
                        "description": "Add the full PEM-encoded cert chain (debug only).",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
