# DomainDNA: Tech Stack Lookup, Email Security & Domain Age API (`cybermax/domain-intel`) Actor

Everything a domain gives away, in one JSON record: tech stack with evidence (CMS, e-commerce, analytics, CDN, payments), MX provider, SPF/DMARC, TLS expiry, domain age via RDAP, security headers and llms.txt. About 1 second and $0.004 per domain.

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

## Pricing

$4.00 / 1,000 domain analyzeds

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/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

## DomainDNA: tech stack lookup, email security & domain age API

**Everything a domain gives away, in one JSON record.** What it runs on, who handles its email,
whether its DMARC is locked down, how old it is and when its certificate expires, in about 1 second
for $0.004 per domain.

### Why DomainDNA

- **One call instead of five lookups.** Tech stack, MX/SPF/DMARC, RDAP registration and domain age,
  TLS certificate and security headers come back together, plus a one-line summary an LLM can quote.
- **Evidence you can check.** Every detected technology shows the header, cookie or script that
  triggered it, so you're not relying on a guess.
- **Fast and cheap at scale.** There's no browser and no proxy, so most domains finish in about 1
  second. Domains that don't resolve are not charged.

**Example summary:**

> shopify.com: runs Shopify, email on Google Workspace, DMARC p=reject, domain 21y old, TLS expires in 60d.

### What you get

Give it a list of domains. For each one you get **one compact JSON record** with:

- **Tech stack** (100+ fingerprints): CMS and site builders (WordPress, Webflow, Wix, Framer…), e-commerce (Shopify, WooCommerce, Magento…), JS frameworks (Next.js, Nuxt, Astro…), CDN and hosting (Cloudflare, Vercel, CloudFront…), analytics, ad pixels, marketing automation, live chat, payments (Stripe, PayPal, Paddle…), consent tools and monitoring. Every detection includes the **evidence** that triggered it.
- **Email setup and security:** MX provider (Google Workspace, Microsoft 365, Proofpoint…), SPF record and `all` qualifier, DMARC policy (`none` / `quarantine` / `reject`), `pct` and reporting.
- **Domain registration (RDAP):** registrar, creation and expiry dates, **domain age in days**.
- **TLS certificate:** issuer, expiry and days left.
- **Security headers** (HSTS, CSP, X-Frame-Options…) with a simple score.
- **Well-known files:** robots.txt, sitemap.xml, **llms.txt**, security.txt.
- DNS basics (A, AAAA, NS), third-party verification tokens (which SaaS tools the domain has verified with), page title, description and language.
- A **one-line summary** an LLM can quote directly.

### Who it's for

- **AI agents and MCP clients** answering "what does acme.com run on?", "is this domain legit / how old is it?" or "can we email them safely?"
- **Sales and lead-gen:** qualify leads by stack ("Shopify stores using Klaviyo", "sites on WordPress without Cloudflare").
- **Security and deliverability checks:** find domains with no DMARC or an expiring certificate.
- **Market research:** stack share across a list of competitors.

### Input

```json
{ "domains": ["apify.com", "https://www.shopify.com/pricing", "wordpress.org"] }
```

Optional switches (all on by default): `includeTech`, `includeDns`, `includeTls`, `includeRdap`, `includeFiles`. `timeoutSecs` (default 15) and `maxConcurrency` (default 10) control speed.

### Output (one item per domain, trimmed)

```json
{
  "domain": "shopify.com",
  "summary": "shopify.com: runs Shopify, email on Google Workspace, DMARC p=reject, domain 21y old, TLS expires in 60d.",
  "reachable": true, "statusCode": 200, "blocked": false,
  "title": "Shopify: The All-in-One Commerce Platform for Businesses",
  "technologies": [
    { "name": "Shopify", "category": "E-commerce", "evidence": "header x-shopid" },
    { "name": "Cloudflare", "category": "CDN", "evidence": "header server" }
  ],
  "email": {
    "mxProvider": "Google Workspace", "mx": ["aspmx.l.google.com"],
    "spf": { "present": true, "allQualifier": "fail", "includes": ["_spf.google.com"] },
    "dmarc": { "present": true, "policy": "reject", "pct": 100, "rua": true }
  },
  "registration": { "registrar": "MarkMonitor Inc.", "createdAt": "2005-…", "ageDays": 7600 },
  "tls": { "issuer": "Google Trust Services", "validTo": "2026-…", "daysLeft": 60 },
  "securityHeaders": { "strictTransportSecurity": true, "contentSecurityPolicy": true, "score": "4/6" },
  "files": { "robotsTxt": true, "sitemapXml": true, "llmsTxt": true, "securityTxt": true },
  "errors": []
}
```

`blocked: true` means the homepage answered with a bot wall (403/429 or a challenge page), so the tech list may be partial. The DNS, email, TLS and registration data are still complete.

### Pricing

Pay per result: one `domain-analyzed` event per domain returned. No subscription. Invalid inputs and domains that don't resolve (`exists: false`) are never charged.

### Notes

- Detection uses our own fingerprint set, matched against the homepage's HTML, headers, cookies and script URLs. It won't see technologies that only load after user interaction.
- DNS is resolved over HTTPS (Cloudflare, falling back to Google). Registration data comes from the official RDAP registries (looked up via the IANA bootstrap file, with retries on rate limits).
- Only public information is collected; no login, no personal data.

# Actor input Schema

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

Domains (acme.com) or URLs (https://www.acme.com/pricing). Each unique domain is analysed once and returns one record.

## `includeTech` (type: `boolean`):

Fetch the homepage and detect CMS, e-commerce, analytics, CDN, payments, chat and framework technologies.

## `includeDns` (type: `boolean`):

MX provider, SPF and DMARC policy, nameservers.

## `includeTls` (type: `boolean`):

Certificate issuer, expiry date and days left.

## `includeRdap` (type: `boolean`):

Registrar, creation date and domain age in days from the official RDAP registry.

## `includeFiles` (type: `boolean`):

Whether each well-known file exists.

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

Timeout for each HTTP, DNS or TLS request.

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

How many domains to analyse at the same time.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "shopify.com",
    "wordpress.org"
  ],
  "includeTech": true,
  "includeDns": true,
  "includeTls": true,
  "includeRdap": true,
  "includeFiles": true,
  "timeoutSecs": 15,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `results` (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": [
        "apify.com",
        "shopify.com",
        "wordpress.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cybermax/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",
        "shopify.com",
        "wordpress.org",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cybermax/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",
    "shopify.com",
    "wordpress.org"
  ]
}' |
apify call cybermax/domain-intel --silent --output-dataset

```

## MCP server setup

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