# 📇 Leads → Notion CRM (Apify MCP Connector) (`nexgendata/leads-to-notion-crm`) Actor

- **URL**: https://apify.com/nexgendata/leads-to-notion-crm.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 verified lead delivereds

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

## 📇 Leads → Notion CRM

**Stop exporting CSVs. Get a ready-to-use CRM.** Give this Actor a list of company domains and your Notion workspace, and it builds you a real Notion **database** — one row per public business contact, complete with company, email, type, verification status, and the source URL — in a single run.

Powered by **Apify MCP connectors**: the Actor writes into *your* Notion on your behalf and **never sees your Notion credentials** (Apify injects them server‑side).

> You don't buy rows. You buy a working lead workspace.

### What you get

A new Notion database (a proper CRM, not a dump) with columns:

| Company | Email | Domain | Type | Verified | Email provider | Source | Added |
|---|---|---|---|---|---|---|---|

- **One row per public business contact** found on the company's own domain.
- **Type** auto-classified (general, sales, support, hr, press, billing, admin, marketing).
- **Verified** = the domain has valid MX records (it can receive mail).
- **Source** = the exact public page each contact was found on.
- A **run summary** (contacts found, leads delivered, domains that returned nothing) in the Actor dataset too.

![Sample Notion CRM output](https://api.apify.com/v2/key-value-stores/8gLgXMBveEI1tTz1z/records/leads-to-notion-crm-output.png)

### 📊 Sample Output

[![Leads to Notion CRM sample output — verified public business contacts for Stripe, Shopify, Figma, Datadog and Anthropic, each with email, contact type, MX-verified status, and email provider, ready to be written into a Notion CRM database](https://api.apify.com/v2/key-value-stores/8gLgXMBveEI1tTz1z/records/leads-to-notion-crm-sample)](https://apify.com/nexgendata/leads-to-notion-crm?fpr=2ayu9b)

Real contacts from a live sample run across **8 domains** (run without a Notion connector to show the underlying dataset that gets written into your CRM — **15 verified contacts across 5 domains**, public business data only):

| Company | Email | Type | Verified MX | Email provider |
|---|---|---|---|---|
| Anthropic | privacy@anthropic.com | business | ✓ | Google Workspace |
| Anthropic | dpo@anthropic.com | business | ✓ | Google Workspace |
| Datadog | info@datadoghq.com | general | ✓ | Google Workspace |
| Figma | privacy@figma.com | business | ✓ | Google Workspace |
| Figma | press@figma.com | press | ✓ | Google Workspace |
| Figma | legal@figma.com | business | ✓ | Google Workspace |
| Shopify | plus@shopify.com | business | ✓ | Google Workspace |
| Stripe | support@stripe.com | support | ✓ | Google Workspace |
| Stripe | privacy@stripe.com | business | ✓ | Google Workspace |
| Stripe | dpo@stripe.com | business | ✓ | Google Workspace |

Each contact also carries `companyName`, `domain`, and the exact `source` page it was found on. The run additionally emits a `run_summary` row (contacts found, leads delivered, and any domains that returned nothing — those are never charged).

### How it works

1. **Authorize a Notion connector once** in Apify Console → *Settings → API & Integrations → MCP connectors* (Notion uses one‑click managed OAuth).
2. Paste your **company domains** and select your **Notion connector** in the input.
3. Run. The Actor finds public business contacts, **creates a Notion database** with a clean schema, and **inserts a row per lead** — then hands you the link.

Optional: set a **Notion parent page ID** to file the CRM under a specific page (otherwise it's created as a private page in your workspace). Leave the connector blank to get the dataset only.

### Inputs

- `domains` — list of company domains/URLs (e.g. `stripe.com`, `https://notion.so`).
- `notionConnector` — your Notion MCP connector (build your CRM automatically).
- `notionParentId` — optional Notion page ID to create the database under.

### Pricing

Pay-per-event. You're charged **only for leads actually delivered into your Notion CRM** — never for discovery attempts or domains that return nothing.

- **$0.01** per Actor start
- **$0.10** per verified lead delivered

You're paying for finished sales infrastructure (a usable CRM), not raw scraped rows.

### Use it responsibly ⚖️

This Actor works **only with public business data** — company domains, company names, and public business email addresses published on the company's own website, each with a source URL. It does **not** collect private personal data, home addresses, or build personal profiles. Use the output to reach businesses responsibly and in line with applicable outreach and privacy laws (e.g. GDPR, CAN‑SPAM, CASL). You are responsible for how you contact the businesses you discover.

### Related NexGenData Actors

- [Company Email Finder](https://apify.com/nexgendata/company-email-finder?fpr=2ayu9b) — the engine behind this CRM, dataset output.
- [B2B Leads Finder](https://apify.com/nexgendata/b2b-leads-finder?fpr=2ayu9b)
- [Company Data Aggregator](https://apify.com/nexgendata/company-data-aggregator?fpr=2ayu9b)
- [Google Maps Scraper](https://apify.com/nexgendata/google-maps-scraper?fpr=2ayu9b)

### FAQ

**Does the Actor see my Notion login?** No. Apify's MCP connector injects your credentials server‑side; the Actor only talks to a proxy. It can only create pages/databases you authorized.

**What if a domain has no public contacts?** It's listed in the run summary as "no results" and you're **not** charged for it.

**Can I reuse one database?** v1 creates a fresh database per run (or under a parent page you choose). Appending to an existing database is on the roadmap.

**Is this affiliated with Notion or the businesses found?** No. It uses Notion's official MCP integration and only public business data.

### About

Built by **NexGenData** — production web-data Actors for AI agents and automation. This is part of our MCP‑connector line: Actors that don't just return data, they put it where you work.

# Actor input Schema

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

Business domains or company URLs to build your CRM from (e.g., 'stripe.com', 'https://notion.so'). Public business data only.
## `notionConnector` (type: `string`):

Connect your Notion workspace and this Actor builds your CRM there in the same run — it never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here. (Without a connector you get the dataset only.)
## `notionParentId` (type: `string`):

Optional. The Notion page ID to create the CRM database under. If blank, Notion creates it as a private page in your workspace.

## Actor input object example

```json
{
  "domains": [
    "apple.com",
    "https://shopify.com"
  ]
}
````

# 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",
        "notion.so"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/leads-to-notion-crm").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",
        "notion.so",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/leads-to-notion-crm").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",
    "notion.so"
  ]
}' |
apify call nexgendata/leads-to-notion-crm --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/leads-to-notion-crm",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📇 Leads → Notion CRM (Apify MCP Connector)",
        "version": "0.0",
        "x-build-id": "ijwnrbF8vAr02Si4w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~leads-to-notion-crm/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-leads-to-notion-crm",
                "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/nexgendata~leads-to-notion-crm/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-leads-to-notion-crm",
                "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/nexgendata~leads-to-notion-crm/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-leads-to-notion-crm",
                "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": "Company Domains",
                        "type": "array",
                        "description": "Business domains or company URLs to build your CRM from (e.g., 'stripe.com', 'https://notion.so'). Public business data only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "notionConnector": {
                        "title": "Notion connector",
                        "type": "string",
                        "description": "Connect your Notion workspace and this Actor builds your CRM there in the same run — it never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here. (Without a connector you get the dataset only.)"
                    },
                    "notionParentId": {
                        "title": "Notion parent page ID (optional)",
                        "type": "string",
                        "description": "Optional. The Notion page ID to create the CRM database under. If blank, Notion creates it as a private page in your workspace."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```