# Shopify Leads Database | $3.90–4.90/1K | Emails & Phones (`apivault_labs/shopify-leads-database`) Actor

Export up to 500,000 indexed Shopify-only domains per run with available emails, phones, exact stored platform evidence and source dates. Filter, deduplicate and export CSV/JSON; actual output depends on data, budget and run resources.

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

## Pricing

from $3.90 / 1,000 shopify store leads

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Shopify Leads Database — Emails, Phones & Bulk Export

![Shopify Leads Database — generated illustration of ecommerce contacts and bulk export](https://raw.githubusercontent.com/apivault-labs/apivault-labs/a2546f2f2e97fb7384d71b5e44707fa211890b28/assets/shopify-leads-database/readme-cover-v1.png)

Build a Shopify prospect list from indexed website records. Every exported domain must carry stored **Shopify or Shopify Plus** technology evidence. Select countries, require available business emails or phone numbers, choose CRM columns and export deduplicated domains to CSV, Excel or JSON.

This is a historical leads database. Stored technology evidence and contact presence do not verify that a store is active today, that an email is deliverable or that a phone is reachable. Source dates accompany every output preset. The Shopify audience size is not yet measured; the wider portfolio's 70M+ records are not a Shopify-only inventory claim.

### First Shopify contact export

```json
{"country":["US"],"hasEmail":true,"maxItems":10,"outputPreset":"contacts"}
```

The default input returns up to 10 domains with a stored email. A platform selector is unnecessary: Shopify/Shopify Plus evidence is mandatory on every row. Supplying `storePlatforms`, `platforms`, traffic options or unknown fields is rejected. Country refers to the stored field, not verified headquarters.

### Useful workflows

| Goal | Supported workflow |
|---|---|
| Shopify app or agency prospects | Export available contact details by country and qualify each business independently. |
| Phone-based research | Require a stored phone and, optionally, a country calling prefix. |
| CRM list preparation | Select columns and keep one row per normalized domain within an export. |
| Audience planning | Count matching source records before a bulk export; the count can include cross-source overlap. |
| Larger lead lists | Use the returned continuation input to fetch the next deterministic page. |

The product does not discover stores through live Shop product searches, provide consumer ratings, fetch product samples, verify inboxes, send outreach or monitor historical changes.

### Ready-to-copy research scenarios

| Scenario | Input choices | Output |
|---|---|---|
| US email prospects | `country: ["US"]`, `hasEmail: true`, `outputPreset: "contacts"` | Stored email contacts and Shopify evidence. |
| UK phone prospects | `country: ["GB"]`, `hasEmail: false`, `hasPhone: true`, `phoneCode: "+44"` | Stored +44 phones; reachability is not verified. |
| Coffee company shortlist | `keyword: "coffee"`, `outputPreset: "sales"` | Company/domain substring matches with sales context. |
| CRM column export | `outputPreset: "custom"`, select `columns` | Selected fields plus mandatory evidence and source dates. |
| Audience count | `workflow: "count"`, `country: ["US"]`, `hasEmail: true` | Matching source-record count before domain deduplication. |

The JSON examples below can be copied into the Actor input now. Five matching saved Tasks have been tested but remain private because of the account's public-Task quota; public one-click Task links are not available yet. A private Task is not a published template.

### Available fields

| Group | Examples and limits |
|---|---|
| Identity | Root Domain, company, stored country/state/city and business category. |
| Contacts | Available Emails, Telephones and social profile strings; optional values can be absent. |
| Shopify evidence | eCommerce Platform, CMS Platform and `_platformEvidence: stored-technology`. |
| Dates | Last Found and Last Indexed where stored; these are not live verification timestamps. |
| Sales context | Available employee counts, technology and estimated revenue/spend fields; estimates are not actual financial results. |

Contacts and technologies are generally semicolon-separated strings. A missing field remains unknown. Evidence and source dates accompany `contacts`, `sales`, `full` and custom presets.

### Real output shape

Taken from a real candidate QA row; identity/contact values are redacted. Optional fields vary.

```json
{
  "Root Domain": "[redacted]",
  "Company": "[redacted]",
  "Country": "",
  "Emails": "[redacted]",
  "Telephones": "",
  "eCommerce Platform": "10 Shopify Products;Shopify;Shopify Local Pickup",
  "CMS Platform": "",
  "Last Found": "2026-06-27",
  "Last Indexed": "2026-06-27",
  "_platformEvidence": "stored-technology"
}
```

### Configure your export

| Input | Behavior |
|---|---|
| `workflow` | `export` (default) or `count`. Count creates diagnostics, not paid Dataset rows. |
| `country` | Optional list of ISO-2 codes; omitted means no country filter. |
| `hasEmail`, `hasPhone` | Require a nonempty stored field before delivery and billing. Email defaults to true. |
| `phoneCode` | Require a stored phone with the supplied prefix, e.g. `+44`. |
| `keyword` | Literal substring in company/domain; not a product-category classifier. |
| `maxItems` | 1–500,000 unique delivered domains, subject to matching data, spending limit, memory and run timeout. |
| `offset` | Deduplicated offset; prefer the continuation input to manual offsets. |
| `outputPreset` | `contacts`, `sales`, `full`, or `custom` with `columns`. |
| `filters` | Allowed column/operator/value conditions, combined with AND. |
| `sortBy`, `sortDesc` | Sort by an allowed stored field; domain ordering is used for continuation. |

#### UK phone prospects

```json
{"country":["GB"],"hasEmail":false,"hasPhone":true,"phoneCode":"+44","maxItems":10,"outputPreset":"contacts"}
```

#### A company/domain keyword shortlist

```json
{"keyword":"coffee","hasEmail":true,"maxItems":10,"outputPreset":"sales"}
```

#### Count the contactable US audience

```json
{"workflow":"count","country":["US"],"hasEmail":true}
```

Read `COUNT_SUMMARY.isComplete` before using the total. The number is matching source records before cross-source domain deduplication, not a count of unique stores or unique emails.

#### Select CRM fields

```json
{"country":["US"],"hasEmail":true,"maxItems":10,"outputPreset":"custom","columns":["Root Domain","Company","Emails","Telephones","Country"]}
```

Mandatory technology evidence and available source dates are included even when omitted from custom columns. Filters apply before result delivery; rejected rows do not create result events.

### Export up to 500,000 Shopify leads in one run

```json
{"maxItems":500000,"hasEmail":true,"outputPreset":"contacts"}
```

At 500,000 delivered rows, result events total **$2,450 on Free or $1,950 on paid plans**, plus startup and platform usage. Set the run spending cap to your intended work; a small cap stops delivery even when `maxItems` is 500000. Count the matching audience first and allow enough memory and time in Run options. The default preview remains 10 rows.

For a large contacts export, start with 1024 MB and 7200 seconds; consider 2048 MB for full output. These are capacity settings, not a measured completion-time guarantee. Use asynchronous runs and download the existing Dataset after completion: a synchronous HTTP wait can end before the Actor finishes. Actual matching unique-domain availability remains unknown until export.

### Continue without repeating domains

After a capped export, read `EXPORT_CONTINUATION.resumeInput` from the run's Key-Value Store and submit it as the next input. Within an export, overlapping sources deduplicate by normalized domain. Independent exports start fresh. The underlying index can change between runs, so continuation is not an immutable snapshot or a guarantee across arbitrary future index updates. Do not change filters or sorting halfway through a continuation chain.

### Read completion and errors

The Dataset contains lead rows only. `SUMMARY`, `ERRORS`, `COUNT_SUMMARY` and `EXPORT_CONTINUATION` contain diagnostics and are not inserted as paid leads. Check completeness after every run: platform `SUCCEEDED` alone does not prove complete source coverage.

An empty matching audience differs from a data-source failure. Partial source access can return useful rows plus explicit warnings. When data cannot be read, report the run ID and source diagnostic rather than claiming there are no Shopify stores. A spending cap stops delivery while retaining rows already written; read the returned continuation before increasing the limit.

### Pricing and costs

Result pricing: **$4.90 per 1,000 delivered domains on Free; $3.90 per 1,000 on Bronze and every higher paid tier**. The existing Actor Start convention is $0.00005 per memory unit (one per GB, minimum one); platform usage is additional. Read the Pricing tab for effective rates on your Apify account.

Count-only, empty results and diagnostic records do not incur lead-result events. Startup and platform usage can still apply. Plan discounts are Apify account tiers, not quantity discounts within a run. No third-party customer API key is required; Apify authentication and billing apply. Service/database/support costs outside Apify run usage are not claimed to be zero.

### API, MCP and developer integrations

Actor slug: `apivault_labs/shopify-leads-database`. Use the current Actor input schema when integrating.

Use the official Apify client or REST API to start a run, wait for its terminal status and retrieve its Dataset and diagnostics. Keep the Apify token in client credentials. CSV and Excel are export formats of the same Dataset, not new source collection modes. Re-read storage from a completed run instead of starting another paid export merely to download a different format.

Apify's hosted MCP `fetch-actor-details` / `call-actor` workflow uses the Actor's exact input schema. Inspect Dataset/diagnostics before presenting contacts. Authenticate with your Apify account and inspect the current Actor details before calling it.

No dedicated npm or PyPI package is currently verified for this new Actor. Existing clients of the wider database do not automatically bind to this slug. Generic Apify HTTP integration is possible in n8n/Make; n8n execution or verification is not claimed.

#### Start an asynchronous API run

Keep `APIFY_TOKEN` in your environment. This small example requests five rows with a $0.08 Actor-charge cap; platform usage is additional.

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/apivault_labs~shopify-leads-database/runs?maxTotalChargeUsd=0.08' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"country":["US"],"hasEmail":true,"maxItems":5,"outputPreset":"contacts"}'
```

Save the returned run ID. Poll `GET /v2/actor-runs/{runId}` until terminal, then use `defaultDatasetId` for `GET /v2/datasets/{datasetId}/items?format=csv`. Use the same Authorization header. Downloading the completed Dataset does not start another lead export. Check `SUMMARY` and `ERRORS` in the run's Key-Value Store before using the list.

Official integration references: [start a run](https://docs.apify.com/api/v2/act-runs-post), [retrieve Dataset items](https://docs.apify.com/api/v2/dataset-items-get), [JavaScript client](https://github.com/apify/apify-client-js), [Python client](https://github.com/apify/apify-client-python), and [Apify MCP](https://docs.apify.com/platform/integrations/mcp). These are generic Apify clients; pass this Actor's exact slug and input. They are not dedicated packages for this product.

#### Pick the matching data product

This Actor exports a historical Shopify-only index. [Store Leads Database](https://apify.com/apivault_labs/store-leads-database) supports multiple ecommerce platforms. [Shopify Store Leads Scraper](https://apify.com/apivault_labs/shopify-store-leads-scraper) is a separate collection workflow; do not assume its inputs, coverage or pricing are identical.

### Frequently asked questions

**Is every result Shopify?** Stored Shopify/Shopify Plus evidence is required in the row's platform fields. A source-group label alone never qualifies. Historical evidence can become stale; verify a store independently when current activity matters.

**Does every row contain an email?** The default `hasEmail: true` requires nonempty stored email text. This is not mailbox validation. With that filter disabled, contact fields can be empty.

**Is the database 70 million Shopify stores?** No. That number belongs to the wider multi-platform portfolio. This product's matching Shopify source count and unique-domain count must be measured separately.

**How does this differ from Shop/Shopify scraping?** It exports indexed websites with stored technology/contact context. It does not run a live product/category search or return shopper ratings.

**Can I export 500,000 in one run?** Set `maxItems: 500000`. The former 10,000 schema limit and hidden 250,000 runtime clip have been removed. Matching data, spending cap, allocated memory and timeout still bound the result. Continuation remains available after a budget stop or a completed capped export; it is not required merely because a run passes 10,000 rows.

**Are the contact details verified?** They are stored business-contact values, not a guarantee of deliverability, ownership, consent or reachability. Qualify them independently.

# Changelog

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

# Actor input Schema

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

Count writes diagnostics only; no paid Dataset rows. Startup 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 500000. Actual output is limited by matching data, spending cap, memory and run timeout. Default 10 is a preview.

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

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

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

Platform evidence and source dates always accompany results. Optional fields can be empty.

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

Used only with custom output preset. Platform evidence and source dates are always included; use full to return all indexed columns.

## `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.

## Actor input object example

```json
{
  "workflow": "export",
  "hasEmail": true,
  "hasPhone": false,
  "maxItems": 10,
  "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",
    "First Detected",
    "Last Found",
    "First Indexed",
    "Last Indexed",
    "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
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/shopify-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/shopify-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 '{}' |
apify call apivault_labs/shopify-leads-database --silent --output-dataset

```

## MCP server setup

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