# Domain Intelligence Website Audit (`seeb/domain-intelligence-website-audit`) Actor

Run Domain Intelligence Website Audit to collect structured public web data with source URLs, clean dataset rows, and guarded execution controls.

- **URL**: https://apify.com/seeb/domain-intelligence-website-audit.md
- **Developed by:** [Techionik](https://apify.com/seeb) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 domain intelligence rows

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

Fast request-based website intelligence for lead generation, agency audits, sales research, enrichment workflows, and monitoring.

This Actor audits company domains without launching a browser. It fetches the public website, optional contact page, and DNS records, then returns a clean row with contact signals, technology stack, email health, lead score, and a practical sales angle.

![Domain Intelligence Website Audit hero](./assets/hero.svg)

### What You Get

- Final website URL and HTTP status
- HTTPS/reachability status
- Page title, H1, meta description, canonical URL, and language
- Public emails and phone numbers from the homepage and contact page
- Social profile links such as LinkedIn, Facebook, Instagram, X, YouTube, GitHub, and TikTok
- Technology signals such as Shopify, WooCommerce, WordPress, Webflow, HubSpot, Klaviyo, Google Analytics, Meta Pixel, Stripe, Cloudflare, React, and Next.js
- MX, SPF, DMARC, and name server signals
- Lead score from 0-100 and lead grade from A-F
- Improvement reasons and a short sales angle
- Optional monitoring changes between runs

### Why This Actor Is Profit-Safe

- It uses HTTP requests and DNS lookups only.
- It does not run a browser.
- It does not use proxies.
- It has request-level and whole-run timeouts.
- One domain normally creates one paid dataset row.
- Invalid inputs, failed domains, and internal notices are saved to the key-value store instead of being written as paid error rows.
- Monitoring snapshots are stored outside the paid dataset.

### Quick Start

1. Add domains such as `stripe.com`, `shopify.com`, or `companycam.com`.
2. Keep **Scan contact page** enabled to find more public emails and phone numbers.
3. Keep **Include DNS email health** enabled for MX, SPF, and DMARC signals.
4. Set **Max domains** to your desired output cap.
5. Run the Actor and download the dataset as JSON, CSV, Excel, or via API.

### Result Limits And Billing

Apify pay-per-event result billing is based on rows written to the default dataset.

- One audited domain normally writes one domain intelligence row.
- **Max domains** is a hard cap.
- The Actor never writes more domain rows than the selected cap.
- Failed fetches are recorded in `latest-notices` in the named key-value store.
- Monitoring state is saved in the named key-value store and does not create paid dataset rows by itself.
- When **Output only the changes** is enabled, the dataset contains only changed domain rows.

Example: if you submit 500 domains and set **Max domains** to 100, the Actor writes at most 100 paid dataset rows.

### Monitoring Logic

When monitoring is enabled, the Actor:

1. Audits each domain.
2. Stores a compact snapshot per domain in the named key-value store.
3. Compares the latest snapshot with the previous snapshot.
4. Saves detected changes to `latest-changes`.
5. Outputs either normal audit rows or change rows depending on **Output only the changes**.

Tracked changes include:

- HTTP status
- Title and meta description
- Public emails and phones
- Social links
- Technology signals
- Lead score and grade

### Output Fields

Common fields include:

- `domain`
- `finalUrl`
- `statusCode`
- `isReachable`
- `isHttps`
- `title`
- `metaDescription`
- `h1`
- `publicEmails`
- `phones`
- `contactPageUrl`
- `socialLinks`
- `technologies`
- `hasMx`
- `mxHosts`
- `spfRecord`
- `dmarcRecord`
- `nameServers`
- `leadScore`
- `leadGrade`
- `improvementReasons`
- `salesAngle`
- `scrapedAt`

### Pricing

This Actor uses pay-per-event pricing.

- Actor start: `$0.003`
- Domain intelligence row:
  - Free tier: `$3.00 per 1,000 rows`
  - Bronze: `$2.50 per 1,000 rows`
  - Silver: `$2.00 per 1,000 rows`
  - Gold, Platinum, and Diamond: `$1.50 per 1,000 rows`

The platform usage cost is low because the Actor is request-based, uses 256 MB by default, and does not launch a browser or proxy. In cloud tests, a 5-domain run cost about `$0.00015` in platform usage, while each successful domain writes one paid domain intelligence row.

Failed domains are stored as key-value store notices instead of paid dataset rows. This keeps billing fair for users and protects the Actor from low-quality paid output.

### Notes

- The Actor reads public website and DNS information only.
- Email discovery is limited to public emails found on the audited pages.
- Some websites block requests or hide contact details behind JavaScript; those cases are logged as notices.
- Technology detection is best-effort and based on visible HTML, scripts, and response headers.

# Actor input Schema

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

Company domains to audit. Examples: stripe.com, shopify.com, example-store.com.

## `urls` (type: `array`):

Optional full website URLs. Use this when you want to audit a specific hostname or landing page domain.

## `maxResults` (type: `integer`):

Maximum domain intelligence rows to write. One domain normally produces one paid dataset row.

## `includeContactPage` (type: `boolean`):

Fetch the first detected contact/about/support page to find additional emails and phone numbers.

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

Check MX, SPF, DMARC, and name server signals. This is request-based and does not use a browser.

## `includeTechnologySignals` (type: `boolean`):

Detect common website, ecommerce, analytics, support, and marketing tools from HTML, scripts, and headers.

## `includeSalesAngle` (type: `boolean`):

Generate a short pitch angle from detected gaps such as missing analytics, email deliverability, contact capture, or ecommerce retention tools.

## `monitorChanges` (type: `boolean`):

Save a snapshot per domain in a named key-value store and compare future runs for changed health, contacts, technology, or score.

## `onlyChanges` (type: `boolean`):

When monitoring is enabled, output only changed domain rows instead of all audit rows.

## `requestTimeoutSeconds` (type: `integer`):

Timeout per HTTP request. Lower values reduce runtime cost; higher values help slow websites.

## `maxRunSeconds` (type: `integer`):

Cost protection timeout for the whole run. The Actor stops before another domain if the budget is nearly exhausted.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "shopify.com"
  ],
  "urls": [
    "https://www.companycam.com/"
  ],
  "maxResults": 100,
  "includeContactPage": true,
  "includeDns": true,
  "includeTechnologySignals": true,
  "includeSalesAngle": true,
  "monitorChanges": false,
  "onlyChanges": false,
  "requestTimeoutSeconds": 15,
  "maxRunSeconds": 300
}
```

# Actor output Schema

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

Normal runs contain one domain intelligence row per audited domain. When Output only the changes is enabled, rows contain change events.

# 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",
        "shopify.com",
        "companycam.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("seeb/domain-intelligence-website-audit").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",
        "shopify.com",
        "companycam.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("seeb/domain-intelligence-website-audit").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",
    "shopify.com",
    "companycam.com"
  ]
}' |
apify call seeb/domain-intelligence-website-audit --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/W64W4E6QSon4Cf0Ec/builds/7yOsDtDZbHKqrIgVm/openapi.json