# Mailchimp Leads Database | $3/1K | Website Contacts (`apivault_labs/mailchimp-leads-database`) Actor

Find Mailchimp leads across compatible indexed sources. Original dataset evidence and exact saved technology matches are labelled separately. Available contacts, filters, deduplication, continuation. $3/1K plus start and resources.

- **URL**: https://apify.com/apivault_labs/mailchimp-leads-database.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 website leads

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

## Mailchimp Leads Database

Find website prospects across compatible datasets using **Mailchimp saved technology matches and original source-dataset membership**, filter by country and available business contacts, and export deduplicated domains as CSV, Excel or JSON. Use the results for reviewed business research, CRM preparation and API workflows.

**$3 per 1,000 delivered results on every Apify plan**, plus $0.00005 per start event per GB of allocated memory, minimum one event. Apify platform usage is additional. The default export can deliver up to 10,000 rows ($30 in result fees at that volume). An explicit 10-row preview costs $0.03 in result fees. Check the Pricing tab for the effective rates on your plan.

### Evidence and inventory

| Coverage snapshot — 8 November 2026 | Value |
|---|---:|
| Search scope | Indexed Mailchimp website records |
| Matching source rows with default evidence mode, no email filter | 1,353,572 |
| Default export | Up to 10,000 domains with stored emails |
| Result price | $3 per 1,000 delivered domains |

Counts are before domain deduplication.

A complete read-only audit found 554,346 exact saved-token source rows, including 434,802 outside the original named group. These are overlapping rows, not distinct websites. The additional Tech Detected Stack field is considered where available. Missing fields are unknown. This is saved evidence, not live detection.

Default export includes original Mailchimp dataset rows plus exact saved-technology matches from other datasets. Original dataset membership alone does not verify the technology for each row. Set `requireStoredTechnology` to true to require an exact saved token on every returned row. Matching checks CMS Platform, eCommerce Platform, Marketing Automation Platform, CRM Platform and Tech Detected Stack where present. Strict mode can return a small or empty audience.

The original named dataset was counted at **918,773 source rows on 8 November 2026**. This is not the number of unique qualified domains, available emails, confirmed installations or active businesses. Filters and domain deduplication reduce the exported audience. Every compatible source table is searched. Original named-dataset membership is distinguished from exact saved-technology matches found in other groups. Domain deduplication applies across sources.

No live website requests, account cookies or external API keys are required from you. Stored fields can be old or missing. No deliverability, phone reachability, current platform installation or consent to receive outreach is implied.

### Quick start

1. The Console starts at 10,000 rows with stored emails. Set maxItems to 10 for a small preview. The example below uses that explicit preview size.
2. Optionally select countries, a literal domain/company keyword or field filters.
3. Run the Actor. Read `SUMMARY` and `ERRORS`, then export the Dataset.

```json
{"workflow":"export","hasEmail":true,"maxItems":10,"outputPreset":"contacts"}
```

For a matching-volume preview:

```json
{"workflow":"count","hasEmail":false}
```

Count-only creates no lead rows or result events, but start and platform usage still apply. The total measures matching source rows before domain deduplication.

### Useful workflows

| Goal | Input | Result |
|---|---|---|
| Review contact prospects | `hasEmail: true`, `maxItems: 10` | Rows with a populated stored email field |
| Build a regional list | `country: ["US", "GB"]` | Stored country codes match the selection |
| Require a phone | `hasPhone: true` | Nonempty stored phone field |
| Find a company or domain | `keyword: "example"` | Literal substring in domain/company, not search-engine results |
| Preview volume | `workflow: "count"` | Matching source-row count, without paid Dataset rows |
| Continue an export | Complete saved `resumeInput` | Next page in the selected source context |
| Select CRM columns | `outputPreset: "custom"`, `columns` | Requested fields plus evidence fields |

### Inputs and limits

| Input | Default / limit | Meaning |
|---|---|---|
| `workflow` | `export` or `count` | Export rows or preview counts |
| `hasEmail`, `hasPhone` | `true`, `false` | Require nonempty stored fields |
| `country` | No filter | ISO-2 codes, normalized to uppercase |
| `requireStoredTechnology` | `false` | Require exact saved target token on every row; otherwise original dataset rows also qualify |
| `keyword` | No filter, up to 100 characters | Literal domain/company substring |
| `phoneCode` | No filter | Stored phone prefix such as `+44`; formatting affects matches |
| `maxItems` | 10,000; range 1–10,000 | Maximum delivered domains |
| `outputPreset` | `contacts` | `contacts`, `sales`, `full` or `custom` |
| `filters` | No extra filters | Allowed field comparisons combined with AND |
| `sortBy`, `sortDesc` | Schema default | Allowed-field ordering and direction |
| `offset` | 0; up to 1,000,000 | Skip eligible domains; prefer full continuation |
| `sourceSession`, `exportCursor` | Omitted | Copy saved continuation without editing |
| `parallelReaders` | Schema default | Bounded read parallelism; same result price |

Allowed filters: `equals`, `not_equals`, `contains`, `not_contains`, `starts_with`, `ends_with`, `in_list`, `not_empty` and `empty`. These compare stored fields. Unknown fields are rejected, including requests to override the Actor with another platform. Private source configuration cannot be supplied by callers. Traffic enrichment is not offered here.

### Output and exports

One paid result is one delivered domain after filters and within-run deduplication. Available fields include Root Domain, Company, Emails, Telephones, Country, State, City, Vertical, social links and stored technology/business signals. Values can be empty. Revenue, employee and spend values are stored signals or estimates, not independently audited facts.

| Output | Interpretation |
|---|---|
| `Root Domain` | Domain identity for deduplication |
| `Emails`, `Telephones` | Stored values, not delivery/reachability verification |
| `CMS Platform`, `eCommerce Platform` | Stored technology strings; empty does not prove absence |
| `Marketing Automation Platform`, `CRM Platform` | Related stored tools, where present |
| `Tech Detected Stack` | Additional saved technology evidence where present |
| `_platform` | Public source-cohort label, not a live detection result |
| `_platformEvidence` | `stored-technology` when that row has an exact saved match; otherwise `source-dataset` |
| `_storedTechnologyMatch` | Exact target-token match in selected stored fields; null for mixed websites |

Illustrative output shape, not a guaranteed or real lead:

```json
{"Root Domain":"example.org","Company":"Example","Emails":"contact@example.org","Country":"US","_platform":"Mailchimp","_platformEvidence":"source-dataset"}
```

Synthetic examples are never inserted into Dataset results. Legacy source timestamps are not exposed by this export policy, so per-row freshness is unknown. The inventory-count date is not the date each website was collected.

### Count, errors and continuation

`SUMMARY` records status, completeness, rows and performance. `evidenceMode` reports the active selection rule in both `SUMMARY` and `COUNT_SUMMARY`: `stored-technology-only` (an exact saved match is required) or `source-dataset-or-stored-technology` (the original dataset also qualifies). `ERRORS` is empty on clean runs. Count mode writes `COUNT_SUMMARY`; its total counts eligible source rows before cross-segment domain deduplication. It is not a distinct-domain or verified-contact count.

After a limit or budget stop, open `EXPORT_CONTINUATION` and copy the complete `resumeInput` into a new run. Keep source session, export cursor, filters and sort together. You may change `maxItems` for the next page. The source context is pinned but tables are live, so concurrent changes can affect pagination. Unrelated exports start at offset 0 without another export's cursor. Within-run deduplication does not suppress older exports unless their saved continuation is used.

An empty result can be legitimate. Source failures are recorded instead of producing fake rows. Read `isComplete` before treating partial results as a full audience count. Validation inside an already-started run can incur start/resources even when no lead is delivered. A successful build alone does not prove source availability.

### API and integrations

Start an asynchronous run, wait for its terminal status, then read the run's Dataset and key-value store:

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/apivault_labs~mailchimp-leads-database/runs' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"workflow":"export","maxItems":10,"hasEmail":true}'
```

Read `https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv` with the authorization header, or select `format=json` / `format=xlsx`. Output links lead to Dataset rows, summary, count preview, errors and continuation.

Use an [n8n HTTP Request node](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/) or the [official Python Apify client](https://docs.apify.com/api/client/python/). A dedicated published package or community node for this Actor has not been verified; no unpublished integration is advertised. See the [Apify API documentation](https://docs.apify.com/api/v2) for run and storage endpoints. You can save your own private input in Console; no public Tasks are required for these examples.

### Result fees

| Delivered rows | Result fees |
|---:|---:|
| 10 | $0.03 |
| 100 | $0.30 |
| 1,000 | $3.00 |
| 10,000 | $30.00 |

Add memory-weighted start and Apify compute/storage/transfer usage. A charge cap can stop delivery before `maxItems`, even when more rows match. Empty/count-only runs have no delivered-row charge but still use resources. These examples are result fees, not a fixed total run cost. Check the actual run charge breakdown.

### FAQ

**Is this a live list of websites using Mailchimp?**

No. It is an indexed historical cohort. Exact saved-token mode, where available, checks stored fields only and does not revisit websites.

**Does every row have an email and phone?**

Only when both corresponding filters are enabled and matching data exists. Missing fields remain empty. Stored contact data does not establish deliverability.

**Is the inventory count the number of unique prospects?**

No. Preview your filters and inspect the deduplicated output. Source segments can overlap.

**Can I request another platform or all 73M+ records here?**

You cannot select unrelated platforms. This Actor searches all compatible tables but returns only original dataset rows or exact saved technology matches. The general database offers unrestricted source selection.

**Why can continuation return fewer rows?**

Filters, deduplication, a charge cap, source changes or errors can reduce delivery. Read summary, errors and continuation instead of assuming only that many websites exist.

# Changelog

This Actor's version history is a separate document: https://apify.com/apivault_labs/mailchimp-leads-database/changelog.md

# Actor input Schema

## `workflow` (type: `string`):

Count reports matching source rows before domain deduplication. It delivers no paid Dataset rows. Start and resource costs still apply.

## `country` (type: `array`):

ISO-2 country codes. Empty means no country filter.

## `keyword` (type: `string`):

Literal substring in domain or company name; not a category classifier.

## `hasEmail` (type: `boolean`):

Keep only sites where the Emails column is not empty.

## `hasPhone` (type: `boolean`):

Keep only sites where the Telephones column is not empty.

## `phoneCode` (type: `string`):

Require at least one stored phone with this country prefix, such as +44.

## `maxItems` (type: `integer`):

Maximum unique domains delivered in this run, 1 to 10000. Default is 10,000. Fewer can match or fit the event budget.

## `offset` (type: `integer`):

Skip this many eligible deduplicated domains. Prefer returned continuation input. Ordering can change as the index changes.

## `outputPreset` (type: `string`):

Stored technology fields accompany every output. Contacts can be missing; cohort membership and saved tokens do not establish current technology or deliverability.

## `columns` (type: `array`):

Used with custom output preset. Stored technology evidence is always included. Historical First/Last date fields are not exported.

## `sortBy` (type: `string`):

Order matching rows before applying the limit. Empty disables explicit ordering.

## `sortDesc` (type: `boolean`):

Highest values first (recommended for scores/traffic/revenue).

## `filters` (type: `array`):

Array of conditions on ANY of the 59 columns. Each item: {"column": "City", "operator": "contains", "value": "Milano"}. Operators: equals, not_equals, contains, not_contains, starts_with, ends_with, in_list (comma-separated), not_empty, empty. Conditions are combined with AND.

## `dataSource` (type: `string`):

Select the indexed website data. To continue an export, copy the complete continuation input.

## `sourceSession` (type: `string`):

Leave empty for a new export. To continue, copy this value from EXPORT_CONTINUATION.resumeInput unchanged.

## `exportCursor` (type: `string`):

Optional encrypted checkpoint from EXPORT_CONTINUATION.resumeInput. Copy the complete resumeInput unchanged except maxItems. Valid for 24 hours and tied to your account and filters. Live changes to indexed records can affect continuation. Omit for a fresh export.

## `parallelReaders` (type: `string`):

Large exports read more source segments at the same time inside this single run. Results go to one Dataset and each accepted result is charged once. Your spending limit still applies. Small exports keep standard reading; available memory and source performance affect speed. You may switch this setting when continuing an export.

## `requireStoredTechnology` (type: `boolean`):

True requires an exact saved Mailchimp token in any available technology field, including Tech Detected Stack. False also includes the original Mailchimp dataset. Neither setting verifies websites live.

## Actor input object example

```json
{
  "workflow": "export",
  "hasEmail": true,
  "hasPhone": false,
  "maxItems": 10000,
  "offset": 0,
  "outputPreset": "contacts",
  "columns": [
    "Root Domain",
    "Location on Site",
    "Primary Domain",
    "Technology Spend",
    "Sales Revenue",
    "Social",
    "Employees",
    "SKU",
    "Company",
    "Vertical",
    "Tranco",
    "Page Rank",
    "Majestic",
    "Umbrella",
    "Overall Score",
    "Performance",
    "Accessibility",
    "SEO",
    "Best Practices",
    "Telephones",
    "Emails",
    "X",
    "Twitter",
    "TikTok",
    "Weibo",
    "Threads",
    "Facebook",
    "LinkedIn",
    "Google",
    "Pinterest",
    "GitHub",
    "Instagram",
    "Vk",
    "Vimeo",
    "YouTube",
    "People",
    "Ticker",
    "Verified Profiles",
    "City",
    "State",
    "Zip",
    "Country",
    "eCommerce Platform",
    "CMS Platform",
    "CRM Platform",
    "Marketing Automation Platform",
    "Payment Platforms",
    "CRuX Rank",
    "Cloudflare Rank",
    "Agency",
    "Has Ads",
    "Hosting Provider",
    "AI",
    "Exclusion",
    "Compliance"
  ],
  "sortBy": "Root Domain",
  "sortDesc": false,
  "dataSource": "warmed",
  "sourceSession": "",
  "parallelReaders": "7",
  "requireStoredTechnology": false
}
```

# Actor output Schema

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

Primary paid output: one structured website or store lead per row. An empty dataset is a valid result and is never filled with diagnostic rows.

## `summary` (type: `string`):

Always present. Contains stable status/error codes, rows returned, completeness, failed or unavailable data segments, and agent-safe next steps.

## `countSummary` (type: `string`):

Present in countOnly mode. Contains match counts per platform and total without paid dataset rows.

## `continuation` (type: `string`):

Contains nextOffset and copy-ready resumeInput after a capped export, spending-limit stop, or completed export.

## `errors` (type: `string`):

Always present as an array; empty on clean runs and populated when input is invalid or data segments fail. Diagnostics are not written to the paid dataset.

# 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 = {
    "workflow": "export",
    "hasEmail": true,
    "maxItems": 10000
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/mailchimp-leads-database").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 = {
    "workflow": "export",
    "hasEmail": True,
    "maxItems": 10000,
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/mailchimp-leads-database").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 '{
  "workflow": "export",
  "hasEmail": true,
  "maxItems": 10000
}' |
apify call apivault_labs/mailchimp-leads-database --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/mailchimp-leads-database"
        }
    }
}
```

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/g5L6IGnrgoh93tB7P/builds/q7ErL3dO7kuVB1PWq/openapi.json