# Shopify Store Leads Scraper – Emails, Socials & Products (`hapol/shopify-store-leads`) Actor

Find Shopify stores by niche keyword, or bulk-check your own domain list to see which ones run Shopify. Get store name, product count, price range, currency, theme, socials and public business emails/phones. Pay only for verified Shopify stores. No proxy, API key or login.

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

## Pricing

from $3.00 / 1,000 verified shopify stores

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 Store Leads Scraper – Emails, Socials & Products

**Shopify Store Leads Scraper** builds a **Shopify store list** for any niche, or checks a list of domains you already have to see which ones run Shopify. Each verified store comes back as a **Shopify store lead**: structured data you can drop into a CRM, spreadsheet or outreach tool. Unlike a static database, this **Shopify store scraper** checks every store live at run time:

- ✅ **Verified Shopify** (4 independent signals, including headless/Hydrogen storefronts)
- 🏷️ Store name, primary domain and `*.myshopify.com` domain
- 📦 **Product count** (exact, from the store's own catalog) and **price range** (min / max / average)
- 💱 Store currency and **Shopify theme** (name + theme store ID)
- 📣 **Social profiles**: Instagram, Facebook, TikTok, YouTube, Pinterest, LinkedIn, X
- ✉️ **Public business contact info**: role emails (info@, hello@, support@…) and phone numbers published on the store's own site
- 🌍 Enriched mode: city / region / country, store description, number of ship-to countries, top product types, vendors, last product published

You only pay for **verified Shopify stores**. Domains that turn out not to be Shopify are free.

### Who uses this Shopify store leads scraper

- **Agencies & freelancers** (Shopify developers, theme designers, CRO/SEO/ads agencies) building prospect lists in a niche
- **SaaS & Shopify app makers** finding stores that fit their app (e.g., by theme, catalog size, price point)
- **Wholesalers, suppliers & 3PLs** finding retailers in their category ("soy candles", "dog treats", "coffee")
- **Market researchers** sizing a niche: how many stores, typical catalog size and price range
- **Sales teams** enriching and cleaning an existing domain list: which domains really run Shopify?

### How to find Shopify stores in a niche

1. **Input**: niche keywords, a list of domains/URLs, or both.
2. **Discovery** (keywords only): candidate stores are found through web search (see below).
3. **Verification**: each candidate is checked with up to four signals:
   Shopify response headers, Shopify code in the homepage, the store's public `/meta.json`, and its public `/products.json` catalog.
   Headless storefronts (custom frontends such as Hydrogen) are detected through their `*.myshopify.com` reference and marked `storefront: "headless"`.
4. **Extraction**: store data, catalog stats, socials and public contact details from the homepage (plus contact/about pages in enriched mode).
5. **Output**: one row per verified store in the dataset (JSON, CSV, Excel, or via API/integrations).

Plain HTTP only (no browser) and no proxy needed, so it's fast and cheap.

### Check if a website is Shopify (bulk Shopify checker)

Already have a list of domains? Put them in `domains` and leave `keywords` empty. Every domain is checked with up to four independent signals:

- Shopify response headers
- Shopify code in the homepage
- the store's public `/meta.json`
- its public `/products.json` catalog

Headless storefronts (custom frontends such as Hydrogen) are recognised through their `*.myshopify.com` reference and marked `storefront: "headless"`. Domains that aren't Shopify are **free**. Set `includeNonShopify: true` to see them in the output too, for example to clean a CRM list.

### Shopify store list by country

There's no built-in country filter yet. To build a Shopify store list for one country:

1. Run discovery with niche keywords, optionally including the country or a city (e.g. "coffee roasters canada").
2. Filter the dataset by `currency` (available in base mode), or by `country` in enriched mode (taken from the store's own public data).

### Discovery methods

| Method | Cost | What to expect |
|---|---|---|
| **Bing – Best-effort / Fast niche discovery** (default) | free (only verified stores are charged) | Best-effort: ~60% of candidates are Shopify, but only a few candidates per keyword. Great for quick, small niche lists. |
| **Google Search** (`discoveryMethod: "google-search-actor"`) | Google results are billed to **your** Apify account by [apify/google-search-scraper](https://apify.com/apify/google-search-scraper), about $0.0045 per results page on the Free tier | ~83% of candidates are Shopify, with far more candidates per keyword. Best for volume. |
| **Your own domain list** (`domains`) | only verified stores are charged | Bring lists from your CRM, a trade directory or a public crawl. |

**Large runs (hundreds or thousands of stores): use the Google option** (`"discoveryMethod": "google-search-actor"`). It costs about **$0.0045 per Google results page**, billed to **your own Apify account/quota** by Apify's Google Search Scraper, on top of this Actor's per-store price.

Tip: try several narrow keywords ("soy candles", "beeswax candles", "candle making supplies") instead of one broad one.

### Input example

```json
{
  "keywords": ["soy candles", "dog treats"],
  "discoveryMethod": "bing",
  "maxStores": 200,
  "enriched": false,
  "roleEmailsOnly": true
}
```

Verify your own list:

```json
{ "domains": ["ugmonk.com", "https://www.taylorstitch.com", "milkhousecandles.com"], "enriched": true }
```

### Output example (base mode)

```json
{
  "domain": "milkhousecandles.com",
  "primaryDomain": "milkhousecandles.com",
  "url": "https://milkhousecandles.com",
  "storeName": "Milkhouse Candle Company",
  "shopifyConfirmed": true,
  "storefront": "online-store",
  "shopifySignals": { "header": true, "html": true, "productsJson": true, "meta": true, "myshopifyRef": true },
  "myshopifyDomain": "15cf4c.myshopify.com",
  "productCount": 396,
  "productCountSource": "meta.json",
  "priceMin": 2.5,
  "priceMax": 950,
  "priceAvg": 47.85,
  "priceSampleSize": 250,
  "currency": "USD",
  "theme": "Stiletto",
  "themeStoreId": 1621,
  "socials": {
    "facebook": "https://facebook.com/MilkhouseCandles",
    "instagram": "https://instagram.com/milkhousecandleco",
    "pinterest": "https://pinterest.com/milkhousecandleco",
    "tiktok": "https://tiktok.com/@milkhousecandles",
    "youtube": "https://youtube.com/channel/UCPk7WgC6JwB64s8BALneWXg"
  },
  "emails": [],
  "phones": [],
  "discoveredBy": "soy candles site:myshopify.com",
  "pagesChecked": ["https://milkhousecandles.com/"],
  "checkedAt": "2026-10-09T20:52:00.050Z"
}
```

### Extra fields in enriched mode

```json
{
  "domain": "ugmonk.com",
  "storeName": "Ugmonk",
  "city": "Downingtown", "province": "Pennsylvania", "country": "US",
  "shipsToCountryCount": 189,
  "topProductTypes": ["Analog", "Journal", "Wood", "Warehouse", "Notebook"],
  "vendors": ["Ugmonk"],
  "lastProductPublishedAt": "2026-10-07T11:16:05-04:00",
  "emails": ["info@ugmonk.com"],
  "pagesChecked": ["https://ugmonk.com/", "https://ugmonk.com/pages/about", "https://ugmonk.com/pages/contact-us"],
  "priceSampleSize": 191
}
```

### How much does it cost to scrape Shopify store leads?

| Event | Price | Per 1,000 |
|---|---|---|
| Verified Shopify store (`store`) | $0.003 | **$3.00** |
| Enriched mode add-on (`enriched-store`) | $0.002 | **+$2.00** |
| Domains that aren't Shopify | free | free |

Examples: 100 stores = $0.30 · 1,000 stores = $3.00 · 1,000 enriched stores = $5.00. Set a **max cost per run** to cap your spend; the Actor stops cleanly when the cap is reached.

### Limits & good to know

- **Contact details** come only from the store's own public pages. Many stores publish no email, or publish only a contact form. Expect emails for a minority of stores in base mode and more in enriched mode.
- By default only **role addresses** (info@, hello@, sales@…) are returned. Named-person addresses are dropped (see "Data protection").
- **Headless stores** don't expose a public catalog, so their product count, price range and theme are empty.
- Some large stores rate-limit or block catalog endpoints. They may then be skipped or verified with fewer fields.
- **Price range** in base mode is computed from the first 250 products. Enriched mode reads up to 1,000 by default (`maxProductPages`, max 10,000).
- **Bing discovery** returns only a handful of candidates per keyword. Use more keywords, or the Google option, for volume.
- Product counts come from Shopify's published-products count and can differ slightly from what the storefront shows.

### Shopify store leads vs. store databases

Tools such as BuiltWith or StoreLeads-style databases sell lists collected in advance. This Actor works differently:

| | This Actor | Prebuilt store database |
|---|---|---|
| When the data is collected | Live, at run time (`checkedAt`) | When the database was last crawled |
| What you pay for | Only stores verified as Shopify in your run | Usually a subscription or a per-record price for the list |
| Your own domain list | Checked one by one (bulk Shopify checker) | Matched against the database |
| Coverage | The niches you search and the domains you bring | Whatever the database has crawled |

Choose a database if you need a huge list at once. Choose this Actor if you want fresh, verified stores for specific niches or want to check your own list.

### Use with the Apify API, integrations and AI agents (MCP)

- **API:** start runs and download results with the [Apify API](https://docs.apify.com/api/v2) or the JavaScript/Python clients.
- **Integrations:** send results to Google Sheets, Zapier, Make, Slack, webhooks and other [Apify integrations](https://docs.apify.com/platform/integrations).
- **Schedules:** re-run a niche weekly with an Apify schedule.
- **AI agents:** like other Store Actors, it can be called by AI agents through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

### FAQ

#### How do I find Shopify stores in a specific niche?

Enter one or more niche keywords (e.g. "soy candles", "dog treats"). The Actor searches for candidate stores and keeps only verified Shopify stores. For volume, use the Google discovery option.

#### How can I tell if a site uses Shopify?

Put the domains in `domains`. Each one is checked with Shopify headers, homepage code, `/meta.json` and `/products.json`, including headless storefronts. Non-Shopify domains are free.

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

No. The default Bing discovery needs no key. The Google option runs Apify's Google Search Scraper on your account and is billed separately.

#### Can I get the store owner's email?

By default you get only **role addresses** the store publishes itself (info@, hello@, sales@…). Addresses that look like a named person are dropped. You can turn this off with `roleEmailsOnly: false`, but read the data protection section first. The Actor never guesses or buys email addresses.

#### Is it legal to scrape Shopify store data?

The Actor reads only public storefront pages and public JSON endpoints that every Shopify store serves to visitors, with no login. How you *use* the data, especially for outreach, is regulated (GDPR, CAN-SPAM, CASL, PECR…). See "Data protection & responsible use" below. This is not legal advice.

#### Is this the official Shopify API?

No. It reads public storefront pages and public JSON endpoints. No login, no private data.

#### How fresh is the data?

It's collected live at run time (`checkedAt`).

### Data protection & responsible use

This Actor collects **publicly available business information** that Shopify merchants publish on their own storefronts: store name, catalog statistics, theme, social profile links, and contact details shown on the store's public pages. It does not log in, bypass access controls, buy or guess email addresses, or use third-party data brokers.

By default (`roleEmailsOnly: true`) it returns only **generic business mailboxes** (for example info@, hello@, support@, sales@) and drops addresses that look like they belong to a named person.

**You are the data controller of the data you collect and are responsible for how you use it.** Before contacting anyone, make sure your use complies with the laws that apply to you and your recipients, for example:

- **GDPR / UK GDPR (EU, EEA, UK):** contact details that identify a person, including those of sole traders and small shops, are personal data. You need a lawful basis, usually legitimate interests with a documented balancing test. You must tell people where you got their data within one month (Art. 14), honor objections and erasure requests, keep only what you need, and secure it.
- **ePrivacy / PECR (EU, UK):** unsolicited marketing emails to individuals and sole traders generally need prior consent. Rules for corporate subscribers are less strict but still require identification and an easy opt-out. Rules vary by EU member state.
- **CAN-SPAM (United States):** commercial emails must not use misleading headers or subject lines, must identify themselves as ads where required, must include a valid physical postal address and a working opt-out, and opt-outs must be honored within 10 business days.
- **CASL (Canada):** commercial electronic messages generally require consent. A conspicuously published business address may give implied consent only if the message relates to the recipient's business role and the address was published without a "no unsolicited messages" statement. Every message must identify the sender and include an unsubscribe mechanism.
- Other laws may apply, such as Australia's Spam Act, Brazil's LGPD and US state privacy laws.

Please also respect each website's terms, don't overload stores (the Actor makes only a few requests per store), and don't use the data for spam, harassment or any unlawful purpose. If you are a store owner and want your data removed from a user's dataset, contact that user. This Actor does not keep a central database.

### Related Actors

- [WooCommerce Store Leads – Wix, Squarespace & BigCommerce](https://apify.com/hapol/ecommerce-store-leads): the same lead data for stores on WooCommerce, Wix, Squarespace and BigCommerce.
- [Greenhouse, Lever & Ashby Jobs API – New Job Alerts](https://apify.com/hapol/job-boards): hiring signals (new job postings) for the companies you're prospecting.

***

Built and maintained by **Hapol Data** (Web Data. Automated.). More Actors: [apify.com/hapol](https://apify.com/hapol).

# Actor input Schema

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

e.g. ugmonk.com or https://www.taylorstitch.com. Each one is verified as Shopify.

## `keywords` (type: `array`):

e.g. "soy candles", "pet accessories". Candidate stores are found by search and then verified.

## `discoveryMethod` (type: `string`):

Bing (default) is free and best-effort: fast for small niche lists, few candidates per keyword. For large runs use Google Search: it runs apify/google-search-scraper on your own Apify account (~$0.0045 per results page on the Free tier).

## `maxSearchPagesPerQuery` (type: `integer`):

Search result pages per query (about 30 results each on Bing). Default 3 for Bing; set 1 for the paid Google option to keep costs low.

## `maxStores` (type: `integer`):

Maximum verified Shopify stores to output.

## `enriched` (type: `boolean`):

Adds location, description, product types/vendors, a fuller price range (more /products.json pages) and contact/about page contacts. Extra charge per store.

## `maxProductPages` (type: `integer`):

250 products per page.

## `roleEmailsOnly` (type: `boolean`):

Keep only generic business addresses (info@, support@, hello@…). Recommended for GDPR.

## `includeNonShopify` (type: `boolean`):

Also output domains that failed verification (free, not charged).

## `proxyConfiguration` (type: `object`):

Proxy

## Actor input object example

```json
{
  "domains": [
    "ugmonk.com",
    "www.taylorstitch.com",
    "milkhousecandles.com"
  ],
  "discoveryMethod": "bing",
  "maxSearchPagesPerQuery": 3,
  "maxStores": 10,
  "enriched": false,
  "maxProductPages": 4,
  "roleEmailsOnly": true,
  "includeNonShopify": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All store records (overview view).

## `contacts` (type: `string`):

Emails, phones and social profiles per store.

## `enriched` (type: `string`):

Location, catalog and shipping details (enriched mode).

## `stats` (type: `string`):

Checked/confirmed counts per query (STATS record).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "ugmonk.com",
        "www.taylorstitch.com",
        "milkhousecandles.com"
    ],
    "maxStores": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("hapol/shopify-store-leads").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domains": [
        "ugmonk.com",
        "www.taylorstitch.com",
        "milkhousecandles.com",
    ],
    "maxStores": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("hapol/shopify-store-leads").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 '{
  "domains": [
    "ugmonk.com",
    "www.taylorstitch.com",
    "milkhousecandles.com"
  ],
  "maxStores": 10
}' |
apify call hapol/shopify-store-leads --silent --output-dataset

```

## MCP server setup

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

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/gI0bt76tE3KYFV8gy/builds/GDnO28GahreGNFIFN/openapi.json