# Email Deliverability Auditor — SPF, DKIM, DMARC & Blacklist (`fayoussef/email-deliverability-auditor`) Actor

Audit any domain's email deliverability: SPF, DKIM, DMARC, MX, MTA-STS, BIMI, DNSSEC and DNS blacklist checks with a 0-100 score and prioritized fixes.

- **URL**: https://apify.com/fayoussef/email-deliverability-auditor.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Developer tools, Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Check email deliverability for any domain in seconds. **Email Deliverability Auditor** reads the public DNS records that decide whether your email lands in the inbox or the spam folder — **SPF, DKIM, DMARC, MX, MTA-STS, BIMI and DNSSEC** — checks your mail server against **DNS blacklists**, and returns a **0–100 deliverability score** with a prioritized list of fixes. Audit one domain or thousands in bulk, export to JSON, CSV or Excel, run it on a schedule, or call it from an API or AI agent.

Since February 2024, **Gmail and Yahoo require SPF, DKIM and DMARC** for anyone sending bulk email. This Actor tells you, per domain, exactly what is configured, what is missing, and what to fix — no login, no SMTP connection, just fast and reliable DNS lookups.

### What does Email Deliverability Auditor do?

It runs a full **email authentication and deliverability audit** on every domain you give it. For each domain it checks:

- **SPF** — is a valid `v=spf1` record present, and is the policy strict (`-all`), soft-fail (`~all`) or dangerously open (`+all`)?
- **DKIM** — probes ~30 common selectors (Google, Microsoft, SendGrid, Mailchimp, Amazon SES, Zoho, Proton and more) plus any selectors you add, and reports which keys exist.
- **DMARC** — is a record present, and is the policy `none`, `quarantine` or `reject`? Is an aggregate-report (`rua`) address set?
- **MX** — can the domain receive mail, and on which servers?
- **MTA-STS**, **BIMI**, **DNSSEC** — the modern trust signals that boost inbox placement and brand visibility.
- **DNS blacklists (DNSBL)** — is the mail server IP listed on SpamCop, SORBS, Barracuda, UCEPROTECT or s5h?

You get a **deliverability score (0–100)**, an **A–F grade**, clear `canSendEmail` / `canReceiveEmail` flags, and a plain-English **recommendations** list. Built on Apify, so you also get scheduling, a REST API, webhooks, integrations (Google Sheets, Slack, Zapier, Make) and monitoring for free.

### Why use Email Deliverability Auditor?

- **Cold email & outreach agencies** — audit every client domain before a campaign so messages don't bounce or land in spam.
- **Email deliverability consultants** — generate a per-domain report and fix list in one run instead of checking records by hand.
- **Sales & lead-gen teams** — validate your sending domains and check prospects' domains for email infrastructure.
- **IT / DevOps / security** — monitor SPF/DKIM/DMARC and SSL-adjacent mail settings across a whole portfolio and catch blacklisting early.
- **Agencies & MSPs** — offer a "free email health check" as a lead magnet, then bulk-audit hundreds of prospect domains.

### How to use Email Deliverability Auditor to check email deliverability

1. Click **Try for free** / open the Actor in Apify Console.
2. In **Domains to audit**, paste your domains, one per line (`example.com`). You can also paste an email address or a URL — the domain is extracted for you.
3. (Optional) Add extra **DKIM selectors** if your provider uses an uncommon one, and toggle **Check DNS blacklists** on or off.
4. Click **Start**. Results stream into the dataset as each domain finishes.
5. **Export** the results as JSON, CSV, Excel or HTML, or pull them from the API.

### Input

Configure everything on the **Input** tab — no code needed. Fields:

- `domains` (required) — list of domains to audit.
- `dkimSelectors` (optional) — extra DKIM selectors to probe.
- `checkBlacklists` (default `true`) — check mail-server IPs against DNS blacklists.
- `concurrency` (default `10`) — how many domains to audit in parallel.

Example input:

```json
{
  "domains": ["example.com", "mycompany.com"],
  "checkBlacklists": true,
  "concurrency": 10
}
````

### Output

One clean record per domain. Download as **JSON, HTML, CSV or Excel**, or fetch from the API.

```json
{
  "domain": "example.com",
  "deliverabilityScore": 82,
  "grade": "B",
  "canSendEmail": true,
  "canReceiveEmail": true,
  "spf": { "found": true, "policy": "soft-fail (~all)", "record": "v=spf1 include:_spf.google.com ~all" },
  "dkim": { "found": true, "selectors": ["google", "selector1"] },
  "dmarc": { "found": true, "policy": "quarantine", "reportingAddress": "mailto:dmarc@example.com" },
  "mx": { "found": true, "servers": ["aspmx.l.google.com"] },
  "mtaSts": { "found": false, "mode": null },
  "bimi": { "found": false },
  "dnssec": { "enabled": false },
  "blacklist": { "checked": true, "listed": false, "listedOn": [], "ipsChecked": ["142.250.110.27"] },
  "recommendations": [
    "DNSSEC is not enabled — turn it on at your DNS host to prevent DNS spoofing.",
    "Add MTA-STS to enforce TLS on inbound mail (optional but recommended)."
  ],
  "checkedAt": "2026-07-10T12:00:00+00:00"
}
```

### Data fields

| Field | Description |
|-------|-------------|
| `domain` | The audited domain |
| `deliverabilityScore` | Overall score 0–100 |
| `grade` | Letter grade A–F |
| `canSendEmail` | SPF + DKIM + DMARC all present |
| `canReceiveEmail` | Domain has MX records |
| `spf` | SPF presence, raw record, enforcement policy |
| `dkim` | DKIM presence and detected selectors |
| `dmarc` | DMARC presence, policy, reporting address |
| `mx` | Mail servers |
| `mtaSts` / `bimi` / `dnssec` | Modern trust-signal checks |
| `blacklist` | DNSBL status of the mail-server IP |
| `recommendations` | Prioritized, plain-English fixes |
| `checkedAt` | ISO-8601 audit timestamp |

### How much does it cost to check email deliverability?

The Actor is lightweight — it makes only DNS queries, so runs are fast and cheap. Free-plan users can audit up to 5 domains per run to try it out. To audit larger lists and unlock full throughput, subscribe to an [Apify plan](https://apify.com/pricing?fpr=youssef). Actual cost depends on your list size and whether blacklist checks are enabled.

### Tips

- Turn **off** blacklist checks for the fastest possible DNS-record-only audit of very large lists.
- If DKIM shows as "not found" for a domain you know signs mail, add its selector under **Extra DKIM selectors** — some providers use custom selector names.
- Schedule a daily or weekly run to **monitor** your sending domains and get alerted (via integration/webhook) when a record changes or an IP gets blacklisted.
- A domain with `canSendEmail: false` is at high risk of landing in spam — fix SPF, DKIM and DMARC first.

### FAQ

#### What is email deliverability?

Email deliverability is whether your messages actually reach the inbox instead of the spam folder or a bounce. It depends heavily on your domain's DNS authentication records — SPF, DKIM and DMARC — which this Actor audits.

#### Do Gmail and Yahoo require DMARC?

Yes. Since February 2024, Gmail and Yahoo require valid SPF, DKIM and DMARC for bulk senders. Domains without them see mail rejected or sent to spam. This Actor shows you exactly which are missing.

#### Is this an email verification tool?

No — email *verification* checks whether a specific address exists. This Actor audits a *domain's* email infrastructure (SPF, DKIM, DMARC, MX, blacklists) to measure deliverability. They solve different problems and work well together.

#### Does it need my email login or send any mail?

No. It only reads public DNS records and (optionally) a public MTA-STS policy file over HTTPS. No credentials, no SMTP, nothing sent.

#### Can I run this from an AI agent or MCP?

Yes. Every Apify Actor is callable from the API and via the Apify MCP server, so an AI agent (Claude, Cursor, custom agents) can audit domains and read the structured results directly.

#### Is checking DNS records legal?

Yes. SPF, DKIM, DMARC, MX and blacklist records are public DNS data published by the domain owner for exactly this purpose. This Actor performs standard, read-only DNS lookups.

### Support & custom solutions

Found a bug or want a new check added? Open an issue on the **Issues** tab.

💼 Need a custom scraping or automation solution? Email **youssefarhan24@gmail.com**.
🌐 Got a site or data source you want an Actor for? [Suggest it here](https://automationbyexperts.com/apify).

# Actor input Schema

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

One or more domains to audit, one per line — for example `example.com`. You can also paste a full email address (`you@example.com`) or a URL (`https://example.com/page`); the domain is extracted automatically.

⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

## `dkimSelectors` (type: `array`):

Optional. Extra DKIM selectors to probe in addition to the ~30 common ones already checked (google, selector1/2, k1, sendgrid, amazonses, etc.). Add your provider's selector here if you know it and it is not detected automatically.

## `checkBlacklists` (type: `boolean`):

When enabled, the mail server IP of each domain is checked against public DNS blacklists (SpamCop, SORBS, Barracuda, UCEPROTECT, s5h). Turn off for a faster, DNS-record-only audit.

## `concurrency` (type: `integer`):

How many domains to audit in parallel. Higher is faster; the default is safe for large lists.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "mycompany.com"
  ],
  "dkimSelectors": [],
  "checkBlacklists": true,
  "concurrency": 10
}
```

# Actor output Schema

## `reports` (type: `string`):

All audited domains with scores, records, and fixes. Switch between dataset views in the table.

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

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/email-deliverability-auditor").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",
        "google.com",
    ],
    "dkimSelectors": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/email-deliverability-auditor").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": [
    "apify.com",
    "google.com"
  ],
  "dkimSelectors": []
}' |
apify call fayoussef/email-deliverability-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Deliverability Auditor — SPF, DKIM, DMARC & Blacklist",
        "description": "Audit any domain's email deliverability: SPF, DKIM, DMARC, MX, MTA-STS, BIMI, DNSSEC and DNS blacklist checks with a 0-100 score and prioritized fixes.",
        "version": "0.1",
        "x-build-id": "6sw30BEfnHgXxukRv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~email-deliverability-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-email-deliverability-auditor",
                "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/fayoussef~email-deliverability-auditor/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-email-deliverability-auditor",
                "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/fayoussef~email-deliverability-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-email-deliverability-auditor",
                "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": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains to audit",
                        "type": "array",
                        "description": "One or more domains to audit, one per line — for example `example.com`. You can also paste a full email address (`you@example.com`) or a URL (`https://example.com/page`); the domain is extracted automatically.\n\n⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).\n💼 Need a custom solution? Reach out at youssefarhan24@gmail.com\n🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dkimSelectors": {
                        "title": "Extra DKIM selectors (optional)",
                        "type": "array",
                        "description": "Optional. Extra DKIM selectors to probe in addition to the ~30 common ones already checked (google, selector1/2, k1, sendgrid, amazonses, etc.). Add your provider's selector here if you know it and it is not detected automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkBlacklists": {
                        "title": "Check DNS blacklists (DNSBL)",
                        "type": "boolean",
                        "description": "When enabled, the mail server IP of each domain is checked against public DNS blacklists (SpamCop, SORBS, Barracuda, UCEPROTECT, s5h). Turn off for a faster, DNS-record-only audit.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many domains to audit in parallel. Higher is faster; the default is safe for large lists.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
