# Store Leads — $6/1K · E-Commerce Emails, Phones & Platforms (`apivault_labs/store-leads-database`) Actor

Search indexed e-commerce leads across seven store platforms. Filter countries and available business emails or phones, count matching records and export deduplicated domains to CSV, Excel, JSON, API or MCP.

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

## Pricing

from $6.00 / 1,000 e-commerce 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.

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

## Store Leads — E-Commerce Emails, Phones & Platforms

![Store Leads — 26.57M indexed records before domain deduplication](https://api.apify.com/v2/key-value-stores/vE2bUTVkFnjAr5uZv/records/readme-cover-v1.png?signature=3a2sk55N9fYgGeNUv8WZ)

Build an e-commerce prospect list from indexed website records. Select a supported store platform, narrow your audience by country or company/domain keyword, require available business emails or phone numbers, and export a list of deduplicated domains.

**26.57 million matching indexed records**, counted on **20 October 2026** across the supported commerce-platform selection with no country or contact-presence restriction. The exact count was **26,570,455 source records**, with complete source coverage and no failed sources. This is a snapshot **before cross-source domain deduplication**, not 26.57 million unique stores, email contacts or currently active businesses. Exported results deduplicate domains; contact filters reduce the matching audience. The index and its counts can change.

This Actor requires stored commerce-platform evidence on every result. A general WordPress, Wix or Squarespace label does not qualify a website as a store. Stored evidence is historical: it does not establish that a store is currently active or that its contacts are deliverable.

### First export

Start with a small list:

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

The dataset contains leads. `SUMMARY` describes completeness and warnings; `ERRORS` describes failures. An empty dataset can be a valid result. Read these diagnostics before increasing the export limit or retrying.

### Supported store platforms

| Selection | Required stored commerce evidence |
|---|---|
| `shopify` | Shopify or Shopify Plus |
| `woocommerce` | WooCommerce or WooCommerce Checkout |
| `magento` | Magento and supported version/edition labels |
| `prestashop` | PrestaShop |
| `bigcommerce` | BigCommerce, v2, v3 or B2B |
| `wix_stores` | Wix Stores |
| `squarespace_commerce` | Squarespace Add to Cart, Commerce or Active Store |

An empty `storePlatforms` selection searches all supported commerce platforms. Available records are checked by their stored technology fields, even when their source dataset was originally organized under another technology. Counts across source datasets and platform labels can overlap.

### Use cases

- Agencies building store migration or maintenance prospect lists.
- App developers finding stores on a specific supported platform.
- Integration teams researching regional e-commerce audiences.
- Sales operations exporting indexed business contacts to a CRM.
- AI agents counting a matching audience before requesting an export.

Qualify leads independently before contacting them. The Actor does not send outreach or validate ownership, consent, mailbox delivery, telephone reachability or current trading activity.

### A real output example

This example is taken from a real release QA result. Identifying and contact values are redacted; it is not a fictional customer record. Optional fields and source dates vary.

```json
{
  "Root Domain": "[redacted]",
  "Company": "[redacted]",
  "Country": "US",
  "Emails": "[redacted]",
  "Telephones": "",
  "eCommerce Platform": "Shopify",
  "CMS Platform": "",
  "Last Found": "2026-07-02",
  "Last Indexed": "2026-07-02",
  "_platformEvidence": "stored-technology"
}
```

The full record is available in your own run Dataset. The exported row retains stored platform evidence; the Actor does not perform live store or mailbox verification.

### Fields and export presets

| Data | Fields and limitations |
|---|---|
| Website identity | `Root Domain`, company and available location fields |
| Business contacts | Available emails, telephones and social profile strings; fields can be empty |
| Commerce evidence | `eCommerce Platform`, `CMS Platform`, `_platformEvidence` |
| Source dates | Available `Last Found` and `Last Indexed`; these are not a live check timestamp |
| Sales context | Available category, employee and estimated revenue/spend fields |

`contacts` focuses on contact and location information. `sales` includes indexed business and technology context. `full` returns all available columns. `custom` uses your `columns` selection. Domain, technology evidence and source dates accompany every preset.

Technology and contact values are generally semicolon-separated strings. Estimated business metrics remain estimates. Missing values do not prove that a business has no contact or technology.

### Count before exporting

```json
{
  "workflow": "count",
  "storePlatforms": ["woocommerce"],
  "country": ["GB"],
  "hasEmail": false
}
```

Read `COUNT_SUMMARY`. It reports matching source records; it is not a global distinct-store count. Check `isComplete` and errors. Count mode writes diagnostics rather than lead rows.

### Phone audience

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

### Controls and limits

| Input | Behavior |
|---|---|
| `workflow` | `export` by default, or `count` |
| `storePlatforms` | Supported commerce platforms; empty selects all |
| `country` | ISO-2 country codes; empty means no country restriction |
| `keyword` | Literal company/domain substring; not a product/category classifier |
| `hasEmail` | Defaults to true; requires a nonempty indexed email field |
| `hasPhone`, `phoneCode` | Require available indexed phone data |
| `maxItems` | 1–10,000 unique domains per export; default 10 |
| `outputPreset`, `columns` | Choose the output fields |
| `filters` | Additional supported column comparisons combined with AND |
| `sortBy`, `sortDesc` | Result ordering; choose a supported column |
| `offset` | Skip eligible deduplicated results; prefer returned continuation |

Source records may contain the same domain more than once. Exports deduplicate across selected data sources. No guarantee is made that fields from every overlapping record will be merged into a single most-current profile.

### Pagination and partial results

After a capped export, read `EXPORT_CONTINUATION` and copy its `resumeInput` into the next run. It preserves the public platform and audience settings. Recover the existing dataset when you only need to download it again; another Actor run repeats work.

The index can change between runs, so pagination is not a frozen snapshot. A source failure must be treated as partial coverage. Check `SUMMARY.isComplete`, source failure counts and `ERRORS` before treating an export or count as complete.

### API, CSV and AI agents

Apify provides JSON, CSV and Excel exports for the default dataset. Use the exact Actor ID **`apivault_labs/store-leads-database`**.

- [GitHub API guide, Python example and manual n8n workflow](https://github.com/apivault-labs/apivault-labs/tree/main/guides/store-leads-database).
- [Hosted MCP endpoint](https://mcp.apify.com?tools=apivault_labs/store-leads-database).
- [Actor input schema](https://apify.com/apivault_labs/store-leads-database/input-schema).

The n8n example uses ordinary HTTP Request nodes and your Apify credential. It is an importable workflow, not a verified community node or an n8n Cloud verification claim. The Python example uses the standard library. No dedicated new npm or PyPI package is claimed; existing Analyzer packages target different Actors.

For MCP, expose `https://mcp.apify.com?tools=apivault_labs/store-leads-database` in your compatible client, authenticate through Apify, and begin with the small JSON input above. Use the returned Dataset and diagnostics, not only the run status.

Agents should start with `maxItems: 10`, use the exact schema enums, inspect diagnostics, and increase volume only after checking useful records and cost controls. Never interpret a successful run alone as proof of complete coverage.

### Pricing and cost controls

**$6 per 1,000 delivered domains** ($0.006 per paid dataset row) on every plan, plus **$0.00005 per start event per GB of Actor memory**, with at least one start event. Apify platform resources are billed separately to the user.

A 10-row sample has $0.06 in lead events before startup and resources. Only useful rows delivered after audience filters and within-run domain deduplication are lead events. Missing optional fields do not make a delivered row free. `count` and empty results produce no paid dataset lead rows, but startup and resources still apply.

Set a small `maxItems` and an appropriate Apify Max total charge. A spending limit can stop delivery before the requested row limit; read `SUMMARY` and `EXPORT_CONTINUATION`. Resource usage varies with filters, selected platforms and source response times. The same page downloaded from its existing Dataset does not start another Actor run.

### FAQ

**How large is the database?** The supported commerce-platform query matched 26,570,455 indexed source records on 20 October 2026, before cross-source domain deduplication. Count mode used `hasEmail: false`, no country filter and all supported store platforms. A global distinct-store inventory has not been measured. Record counts, unique domains, records with contacts and currently active stores are different measurements.

**Are ordinary Wix or WordPress sites included?** Only if the same row contains supported commerce-platform evidence. A CMS label alone is insufficient.

**Is every email or phone present and verified?** No. Contact availability varies. Filters test stored field presence, not delivery or reachability.

**Is this live store scraping?** No. It searches indexed records with stored technology evidence and available source dates.

**Why can I get fewer results than requested?** Audience filters, deduplication, available records, spending limits or source failures can reduce delivery. Read diagnostics to distinguish them.

# Changelog

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

# Actor input Schema

## `storePlatforms` (type: `array`):

Empty searches all supported commerce technologies. General CMS names alone never qualify.

## `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 10000. 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`):

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
{
  "storePlatforms": [],
  "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/store-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/store-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/store-leads-database --silent --output-dataset

```

## MCP server setup

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