# Shopify Store Leads - DTC Brand Finder (`flash_scraper/shopify-leads-scraper`) Actor

Turn a niche (or a list of Shopify stores) into a contactable DTC lead list — store name, website/domain, email (found on each store site), phone, category, socials, a 0-100 lead score, dedupe, plus revenue/tech signals and optional AI cold openers. Export CSV/JSON.

- **URL**: https://apify.com/flash\_scraper/shopify-leads-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** Lead generation, E-commerce, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 leads

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

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

## Shopify Leads Scraper — D2C merchant leads with owner email, phone & tech stack

Turn a list of Shopify store URLs into a contactable **Shopify / D2C merchant lead list** — owner email, phone, social profiles, tech-stack signals, and a 0-100 lead score. **$5 per 1,000 leads** — pay only for results you actually get.

### What does it do?

This actor takes **Shopify store URLs you provide** and audits each one, then **crawls the store's own website** (home, /contact, /contact-us, /about, /pages/contact) to extract a real contact **email**, phone, and social links — including resolving link-in-bio pages (Linktree, Beacons) back to the brand's actual domain. Every lead gets a **lead score**, an `email_status` flag, and best-effort **revenue and tech-stack signals** (installed apps, theme) when the underlying store audit exposes them. The result is a clean, deduped **B2B lead list of Shopify merchants**, ready for cold outreach.

### Why use it / who's it for

- **Shopify app developers and theme/CRO agencies** who need a real list of stores to pitch, with a working email — not just a directory of URLs.
- **Email/SMS marketing platforms** (Klaviyo-style tools) prospecting DTC brands that need better retention or flows.
- **3PLs, freight, and fulfillment companies** targeting growing Shopify stores that have outgrown their current logistics setup.
- **Agencies selling into D2C brands** (paid media, CRO, email design) who want owner contact info plus tech-stack context before they pitch.
- **Anyone running cold outreach to Shopify store owners** who needs verified emails, not a scraped list of domains with no way to reach anyone.

### How to use it

1. Provide a list of **Shopify store URLs** (`storeUrls`) — one per store, e.g. `https://allbirds.com`. This actor audits explicit store URLs; it does not discover stores from a niche or keyword.
2. Set `maxItems` to cap how many stores get processed.
3. Leave `enrichEmails` on (default) to crawl each store's own site for a contact email and socials — no key needed.
4. Optionally set `onlyWithEmail` and/or `onlyWithWebsite` to keep only cold-email-ready rows — you're only charged for leads delivered after filters run.
5. Optionally enable `writeOpeners` with your own OpenAI/Anthropic key to get a personalized one-sentence cold-outreach opener per lead.
6. Run it, then export the dataset to CSV, JSON, or Excel.

### Output fields

| Field | Description |
|---|---|
| `name` | Store / brand name |
| `website` | Store's website URL |
| `domain` | Bare domain |
| `category` | Product category / vendor signal, when the store audit exposes it |
| `phone` | Phone number, when available |
| `email` | Contact email, extracted by crawling the store's own site |
| `email_status` | `found` or `missing` |
| `instagram`, `facebook`, `tiktok`, `twitter`, `linkedin` | Social profile URLs found on the site |
| `revenue_estimate` | Best-effort revenue/scale signal, when the underlying store audit exposes one |
| `tech` | Installed apps / theme signal, when available |
| `lead_score` | 0–100 score: email +40, phone +10, website +15, revenue signal +15, tech-stack signal +10 |
| `icebreaker` *(optional)* | A personalized one-sentence cold-outreach opener, written with your own OpenAI/Anthropic key when `writeOpeners` is on |

Rows are deduped by domain, then email, then name, and sorted best-lead-first.

### Input example

```json
{
  "storeUrls": ["https://allbirds.com", "https://www.gymshark.com"],
  "maxItems": 50,
  "enrichEmails": true,
  "onlyWithEmail": false,
  "onlyWithWebsite": false,
  "writeOpeners": false
}
````

`storeUrls` is required — this actor enriches explicit Shopify store URLs, it does **not** search or discover stores by niche/keyword. Every other field has a sensible default.

### How much does it cost?

This actor uses **pay-per-event pricing: $0.005 per result ($5 per 1,000 leads)**, effective 2026-07-16. You're charged only for leads actually delivered after your filters (`onlyWithEmail`/`onlyWithWebsite`) are applied — no subscription, no charge for empty runs. An optional extra event is billed only if you enable AI openers and one is successfully written. New Apify accounts get roughly **1,000 free results per month** on the platform's free tier, so you can enrich a full batch of stores and check the email fill-rate before paying anything. A 5,000-lead batch costs $25; a 20,000-lead prospecting run across hundreds of stores costs $100.

### FAQ

#### Is it legal to scrape Shopify store contact and tech-stack data?

Yes. This actor only reads **publicly available data** — each store's own public website (home, contact, about pages) and store metadata exposed by the underlying store audit. It doesn't log in, bypass paywalls, or access private data. Always follow applicable email-outreach laws (CAN-SPAM, GDPR, etc.) once you use the leads.

#### Can I give it a niche or keyword instead of URLs?

No — the input schema has a niche/keyword field for convenience, but there is no Shopify-wide store search behind it. This actor only audits **explicit store URLs you provide** in `storeUrls`. If you give it a keyword with no URLs, the run will fail with a clear error telling you to supply store URLs instead.

#### How fresh is the data?

Emails, phones, and social links are extracted by **crawling each store's live website** during the run, so results reflect what's published today, not a cached snapshot. Re-run the actor periodically if you're tracking a list of stores over time.

#### How accurate is the email match?

The crawler checks the store's homepage plus common contact pages (`/contact`, `/contact-us`, `/about`, `/pages/contact`, `/pages/contact-us`) and follows link-in-bio redirects back to the real domain. `email_status: found` means an email was actually located on the site; `missing` means none was found — those rows still carry a lower `lead_score` so you can filter them out with `onlyWithEmail`.

#### Do I need an API key or proxy?

No, unless you turn on `writeOpeners`, which requires your own OpenAI or Anthropic key (used only for that call, never stored). Store auditing and email enrichment need no key and run fine without extra setup.

### Other Flash Scrape lead tools

- [Local Business Leads Scraper](https://apify.com/flash_scraper/local-business-leads) — any local business category, by city, with website platform detection
- [Google Maps Leads Scraper](https://apify.com/flash_scraper/google-maps-leads-opener) — Google Maps business leads with AI-written cold-email openers
- [Company & Domain Enricher](https://apify.com/flash_scraper/company-domain-enricher) — turn a domain list into full company records with tech stack and socials
- [Bulk Email Verifier](https://apify.com/flash_scraper/email-verifier) — verify and score every email address before you send a campaign
- [Restaurant Leads Scraper](https://apify.com/flash_scraper/restaurant-leads-scraper) — restaurant leads segmented by POS, reservation, and delivery tech stack

# Actor input Schema

## `searchTerms` (type: `array`):

Product niches / keywords for the Shopify brands you want — one per line. e.g. 'skincare', 'coffee', 'pet supplies', 'activewear'.

## `storeUrls` (type: `array`):

Known Shopify store URLs to audit directly — one per line. e.g. 'https://allbirds.com'. Use this when you already have a list of stores to enrich into leads.

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

Maximum number of Shopify stores to scrape into leads.

## `onlyWithWebsite` (type: `boolean`):

Drop rows with no website/domain (you can't enrich an email without one).

## `onlyWithEmail` (type: `boolean`):

Drop stores where no email could be found. Best for cold-email campaigns.

## `enrichEmails` (type: `boolean`):

Visit each store website (home + /contact + /about + /pages/contact) to extract emails and social links. Higher email fill-rate. No key needed.

## `writeOpeners` (type: `boolean`):

Generate a personalized one-sentence outreach opener for each lead. Requires your OpenAI/Anthropic key below.

## `llmProvider` (type: `string`):

AI provider used to write the cold openers — OpenAI (GPT) or Anthropic (Claude). Use the provider that matches the LLM API key you supply.

## `llmApiKey` (type: `string`):

Your own OpenAI or Anthropic API key. Used only to write the openers; never stored.

## `llmModel` (type: `string`):

Override the default model (gpt-4o-mini for OpenAI, claude-haiku-4-5-20251001 for Anthropic).

## Actor input object example

```json
{
  "searchTerms": [
    "coffee",
    "activewear"
  ],
  "storeUrls": [
    "https://allbirds.com",
    "https://www.gymshark.com"
  ],
  "maxItems": 50,
  "onlyWithWebsite": false,
  "onlyWithEmail": false,
  "enrichEmails": true,
  "writeOpeners": false,
  "llmProvider": "openai"
}
```

# Actor output Schema

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

No description

# 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 = {
    "storeUrls": [
        "https://www.allbirds.com",
        "https://www.gymshark.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/shopify-leads-scraper").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 = { "storeUrls": [
        "https://www.allbirds.com",
        "https://www.gymshark.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("flash_scraper/shopify-leads-scraper").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 '{
  "storeUrls": [
    "https://www.allbirds.com",
    "https://www.gymshark.com"
  ]
}' |
apify call flash_scraper/shopify-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Leads - DTC Brand Finder",
        "description": "Turn a niche (or a list of Shopify stores) into a contactable DTC lead list — store name, website/domain, email (found on each store site), phone, category, socials, a 0-100 lead score, dedupe, plus revenue/tech signals and optional AI cold openers. Export CSV/JSON.",
        "version": "0.1",
        "x-build-id": "8dYQP2zMEMt5WaeeL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/flash_scraper~shopify-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-flash_scraper-shopify-leads-scraper",
                "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/flash_scraper~shopify-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-flash_scraper-shopify-leads-scraper",
                "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/flash_scraper~shopify-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-flash_scraper-shopify-leads-scraper",
                "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",
                "properties": {
                    "searchTerms": {
                        "title": "Niche / keywords (what)",
                        "type": "array",
                        "description": "Product niches / keywords for the Shopify brands you want — one per line. e.g. 'skincare', 'coffee', 'pet supplies', 'activewear'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "storeUrls": {
                        "title": "Shopify store URLs (optional)",
                        "type": "array",
                        "description": "Known Shopify store URLs to audit directly — one per line. e.g. 'https://allbirds.com'. Use this when you already have a list of stores to enrich into leads.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max stores",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of Shopify stores to scrape into leads.",
                        "default": 50
                    },
                    "onlyWithWebsite": {
                        "title": "Only stores with a website",
                        "type": "boolean",
                        "description": "Drop rows with no website/domain (you can't enrich an email without one).",
                        "default": false
                    },
                    "onlyWithEmail": {
                        "title": "Only stores with an email",
                        "type": "boolean",
                        "description": "Drop stores where no email could be found. Best for cold-email campaigns.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Find emails on the store website",
                        "type": "boolean",
                        "description": "Visit each store website (home + /contact + /about + /pages/contact) to extract emails and social links. Higher email fill-rate. No key needed.",
                        "default": true
                    },
                    "writeOpeners": {
                        "title": "Write an AI cold-opener per lead",
                        "type": "boolean",
                        "description": "Generate a personalized one-sentence outreach opener for each lead. Requires your OpenAI/Anthropic key below.",
                        "default": false
                    },
                    "llmProvider": {
                        "title": "AI provider (for openers)",
                        "enum": [
                            "openai",
                            "anthropic"
                        ],
                        "type": "string",
                        "description": "AI provider used to write the cold openers — OpenAI (GPT) or Anthropic (Claude). Use the provider that matches the LLM API key you supply.",
                        "default": "openai"
                    },
                    "llmApiKey": {
                        "title": "AI API key (for openers)",
                        "type": "string",
                        "description": "Your own OpenAI or Anthropic API key. Used only to write the openers; never stored."
                    },
                    "llmModel": {
                        "title": "AI model (optional)",
                        "type": "string",
                        "description": "Override the default model (gpt-4o-mini for OpenAI, claude-haiku-4-5-20251001 for Anthropic)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
