# Shopify Leads & Store Scraper: Apps, Contacts | $4/1k (`transparent_meteorite/shopify-store-leads`) Actor

Shopify leads: 60+ apps and theme detected per store, myshopify domain, country, product count, price range, review rating, sample products, emails, phones, socials. Filter by category, location, price; new-stores-only monitor mode. $0.004 per store.

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

## Pricing

Pay per event

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 Leads: installed apps, products, theme and contacts for any Shopify store

![Shopify Leads & Store Scraper: features, price and a real output row](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-shopify-store-leads-banner-10140227.png)

[![Run it free on Apify](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-cta.png)](https://console.apify.com/actors/EaDAilrkHBSdUEfl1/input)

| Price per 1,000 stores | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$4.00** | **$4.00** | **$4.00** | **$4.00** |

<sub>Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-13; check the Pricing tab for the current figure.</sub>

![Shopify Leads & Store Scraper sample output table from a real run](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-shopify-store-leads-output-10140227.png)

**Video walkthrough:** [Watch the 1-minute demo on YouTube](https://www.youtube.com/watch?v=QnWa6sQRPhY)

![Shopify Store Leads output preview: real run results as a table](https://open-data-actors.pages.dev/img/shopify-store-leads.png)

![Shopify Store Leads on Apify](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/banner-shopify-store-leads.png)

![Shopify Store Leads sample output table](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/output-shopify-store-leads.png)

- **In short:** Shopify Store Leads (Apify actor `transparent_meteorite/shopify-store-leads`) detects Shopify stores and returns store data, installed apps, theme, catalog stats and contacts; can also discover stores by niche keyword.
- **Who it is for:** Shopify app and agency sales teams, ecommerce investors, D2C market researchers.
- **Input:** store domains or niche keywords, max stores, include products, max products per store.
- **Output:** store name, myshopify domain, country, currency, product count, price range, vendors, theme, 60+ detectable apps, last activity, emails, phones, socials.
- **Price:** $0.004 per store analyzed, $0.0005 per product row, $0.00005 per run start. Pay per result, no subscription; Apify's free plan credit covers a first test.
- **Limits:** app detection covers apps that leave a public footprint; revenue and traffic are not estimated.

**Key facts**

- Actor name: Shopify Store Leads
- Actor ID: `transparent_meteorite/shopify-store-leads`
- Store page: https://apify.com/transparent_meteorite/shopify-store-leads
- Data source: each store's public storefront and its public products.json
- Pricing model: pay per event (`apify-actor-start` $0.00005, `store-analyzed` $0.004, `product-row` $0.0005)
- Output formats: JSON, CSV, Excel, XML, HTML table, RSS (Apify dataset)
- Access: Apify Console, REST API, JavaScript/Python clients, schedules, webhooks, Apify MCP server
- Login or third-party API key needed: no, only an Apify account
- Also known as: Shopify store finder, Shopify leads scraper, Shopify apps detector, find Shopify stores by niche, Shopify store emails
- Maintainer: transparent_meteorite (independent developer)
- Last updated: 2026-10-07

Turn a list of websites (or a niche keyword) into qualified Shopify leads: store name, myshopify domain, country, currency, product count, price range, vendors, theme, **60+ installed apps** (Klaviyo, Yotpo, Judge.me, ReCharge, Gorgias...), catalog activity and business contact details. **$0.004 per store, $4 per 1,000.**

Shopify leads you can qualify before the first email: check a list of domains (or discover stores by niche keyword) and see for each store whether it runs on Shopify, which apps and theme it uses, how big the catalog is and which contact details it publishes.

**Run it now.** Paste this into the Input tab (JSON view) and press Start:

```json
{
  "domains": [
    "allbirds.com",
    "brooklinen.com",
    "colourpop.com",
    "deathwishcoffee.com",
    "kyliecosmetics.com"
  ],
  "keywords": [],
  "maxStores": 5,
  "includeProducts": false
}
```

At most 5 stores x $0.004 plus a $0.00005 start fee = **about $0.02** for this input. Domains that are not Shopify get a free row. Measured: default-input test runs on 2026-10-11 (1 store) took 2.8 to 3.2 seconds of run time.

### Run in 30 seconds

1. Open the [prefilled run](https://console.apify.com/create-task-from-example/evtoJDlmjPhgKU5NE) (free Apify account; it creates a saved task with a working input).
2. Press **Start**. The input is small on purpose, so the first run is quick and costs a few cents at most.
3. Open the **Output** tab, switch to Table view, download as CSV, Excel or JSON.

Ready-made presets by use case (each opens as a saved task you can edit):

- [DTC brand prospecting list](https://console.apify.com/create-task-from-example/XdDJGp2pFNqGQ51cv)
- [Competitor product catalog sample](https://console.apify.com/create-task-from-example/SGr3SDrc79ONvys3A)

### Why choose this over alternatives

- Detects 60+ installed Shopify apps (Klaviyo, Yotpo, ReCharge and more) plus the theme, so you can target by stack.
- Store name, myshopify domain, country, currency, product count, price range, vendors, activity, emails, phones and socials.
- Discover stores by niche keyword, or paste your own list.
- $0.004 per store analyzed.

| Check | This actor |
|---|---|
| Apps detected | 60+ |
| Verification run | 5 stores analyzed in 10 s |

Measured 2026-10-09 (source: this actor's own test suite and runs).

### What does Shopify Store Leads do?

For every domain you give it, the actor:

1. **Detects Shopify** from four independent signals: `/meta.json`, Shopify response headers, `cdn.shopify.com` assets and the `Shopify.shop` storefront variable. Non-Shopify sites come back as a free `isShopify: false` row.
2. **Profiles the store** from public storefront endpoints: store name, primary and `*.myshopify.com` domain, Shopify shop ID, country, state, city, currency, number of ship-to countries, published product and collection counts, Shop Pay Installments.
3. **Summarizes the catalog** from `/products.json` (up to 500 products by default): min / median / max price, % on sale, % in stock, top vendors, product types, tags, top collections.
4. **Measures activity**: last product published, last product updated, days since last update, new products in the last 30 days. Dead stores stand out immediately.
5. **Fingerprints the tech stack**: theme name (Dawn, custom...), theme store ID, and 60+ apps across email/SMS, reviews, loyalty, subscriptions, upsell, search, support, BNPL, returns, attribution and ad pixels.
6. **Collects business contacts** published on the homepage and `/pages/contact`: role emails (info@, support@, hello@...), phone numbers, Instagram, Facebook, TikTok, X, YouTube, Pinterest, LinkedIn.
7. Optionally **outputs every product** as its own row (title, URL, vendor, type, tags, price range, compare-at price, availability, variants, SKUs, image, dates).

**Discovery mode**: type a niche such as `coffee roaster`, `candles` or `dog treats` and the actor finds matching `*.myshopify.com` stores in the public [Common Crawl](https://commoncrawl.org) URL index, then analyzes each one. No Google scraping.

### Why use it?

- **App-level targeting.** Sell a Klaviyo alternative? Filter stores that run Klaviyo. Selling reviews? Find stores with no reviews app. This returns the stack as well as contacts.
- **Activity signal.** `daysSinceLastProductUpdate` and `newProductsLast30Days` separate active merchants from abandoned stores before you spend outreach on them.
- **Catalog sizing.** Product count, price band and vendors tell you store size and positioning at a glance.
- **Cheap and honest pricing.** $0.004 per live Shopify store. Non-Shopify domains, closed stores, duplicates and malformed input are **never charged**.
- **Fast and clean.** Plain HTTPS to public endpoints, no residential proxies, no browser. 5 stores in a few seconds.
- **Privacy-minded.** Only business contact data the store itself publishes; personal-name emails are filtered out.

### How to use

1. Click **Try for free** (or Start).
2. Paste store domains or URLs into **Store domains or URLs**, and/or add niche words to **Discover stores by niche keyword**.
3. Set **Max stores**. Turn on **Also output products** if you need the catalog.
4. Run. Open the **Store leads** view, or export to CSV, Excel or JSON.

#### Filters and monitor mode (v0.2)

| Input | What it does |
|---|---|
| `category` | Keep only stores whose name, description, collections, product types, tags or vendors match (e.g. `coffee`). |
| `storeLocation` | Keep only stores in these countries, provinces or cities (`US`, `Canada`, `Texas`). |
| `priceMin` / `priceMax` | Keep stores whose median product price falls in this range (store currency). |
| `skipPreviouslyScraped` | Monitor mode: only stores never delivered before (state kept in the named key-value store `shopify-store-leads-state`), ideal for schedules. |
| `includeRatings` | Read one product page per store for the star rating and total product reviews (default on). |

Stores removed by a filter or by monitor mode are never charged. New output fields: `myshopifyDomain`, `sampleProducts` (5 products with price and image), `ratingValue`, `totalProductReviews`, `reviewSource`, `socialLinksCount` (plus the existing Instagram, Facebook, TikTok, X, YouTube, Pinterest and LinkedIn links). Running with empty input analyzes five demo stores.

#### Input example

```json
{
  "domains": ["allbirds.com", "brooklinen.com", "colourpop.com", "deathwishcoffee.com", "kyliecosmetics.com"],
  "keywords": ["coffee roaster"],
  "maxStores": 50,
  "includeProducts": false
}
```

### Output

#### Sample (real rows from a platform run, October 2026)

| Store | myshopify domain | Country | Products | Price min / median / max | Theme | Apps | Sample apps | Email | Instagram |
|---|---|---|---|---|---|---|---|---|---|
| Allbirds | weareallbirds.myshopify.com | US | 692 | 0.8 / 100 / 165 USD | allbirds-theme | 4 | Attentive, Elevar, Microsoft Clarity | help@allbirds.com | instagram.com/allbirds |
| Brooklinen | brooklinen2.myshopify.com | US | 495 | 0 / 55 / 1,084 USD | Dawn | 8 | Attentive, Yotpo, Swym Wishlist | hello@brooklinen.com | instagram.com/brooklinen |
| ColourPop | colourpop-prd.myshopify.com | US | 1,049 | 5 / 12 / 159 USD | Colourpop | 14 | Klaviyo, Attentive, Yotpo, Okendo | | instagram.com/colourpopcosmetics |
| Death Wish Coffee | deathwishcoffee.myshopify.com | US | 147 | 5.99 / 29.98 / 90 USD | Dawn | 8 | Klaviyo, Postscript, Smile.io, ReCharge | hey@deathwishcoffee.com | instagram.com/deathwishcoffee |
| Kylie Cosmetics | kylie-jenner-us.myshopify.com | US | 247 | 0 / 38.7 / 276.3 USD | KYLIE | 9 | Klaviyo, Attentive, Yotpo, ReCharge | | instagram.com/kyliecosmetics |

#### One store row (JSON, trimmed)

```json
{
  "rowType": "store",
  "inputDomain": "deathwishcoffee.com",
  "isShopify": true,
  "storeStatus": "live",
  "storeName": "Death Wish Coffee",
  "primaryDomain": "www.deathwishcoffee.com",
  "myshopifyDomain": "deathwishcoffee.myshopify.com",
  "country": "US", "province": "New York", "city": "Round Lake", "currency": "USD",
  "shipsToCountriesCount": 224,
  "productCount": 147, "publishedCollectionsCount": 126,
  "priceMin": 5.99, "priceMedian": 29.98, "priceMax": 90,
  "productsOnSalePct": 16, "productsAvailablePct": 97,
  "topVendors": ["Death Wish Coffee Company", "Sportiqe", "Planet Apparel"],
  "topProductTypes": ["Apparel", "Coffee", "Coffee Bundle", "Accessories"],
  "themeName": "Dawn",
  "appsDetected": ["Klaviyo", "Postscript", "Smile.io", "ReCharge", "Rebuy", "Gorgias", "Google Analytics / GTM", "Google Ads"],
  "appCount": 8,
  "appCategories": ["Email & SMS", "Loyalty", "Subscriptions", "Upsell", "Support", "Analytics", "Ads pixel"],
  "lastProductPublishedAt": "2026-09-30T13:47:05.000Z",
  "daysSinceLastProductUpdate": 0,
  "newProductsLast30Days": 11,
  "contactEmail": "hey@deathwishcoffee.com",
  "instagram": "https://www.instagram.com/deathwishcoffee",
  "facebook": "https://www.facebook.com/deathwishcoffee",
  "x": "https://x.com/deathwishcoffee",
  "errors": {}
}
```

Store rows have `rowType: "store"`, product rows `rowType: "product"`. The dataset has two views, **Store leads** and **Products**.

#### Sample output (real run, truncated)

```json
{
  "rowType": "store",
  "inputDomain": "colourpop.com",
  "isShopify": true,
  "detectionSignals": [
    "meta.json",
    "headers",
    "cdn.shopify.com",
    "Shopify.shop"
  ],
  "storeStatus": "live",
  "storeName": "ColourPop",
  "storeUrl": "https://colourpop.com",
  "primaryDomain": "colourpop.com",
  "myshopifyDomain": "colourpop-prd.myshopify.com",
  "shopId": 13380845,
  "description": "Shop ColourPop® top-rated makeup for eyes, lips & face. From Super Shock Shadow to glossy balms & liners, plus iconic collabs. Find your match - shop now!",
  "country": "US",
  "province": "California",
  "city": "Oxnard",
  "currency": "USD",
  "shipsToCountriesCount": 184,
  "publishedProductsCount": 1061,
  "publishedCollectionsCount": 190,
  "shopPayInstallments": false,
  "themeName": "Colourpop",
  "themeStoreId": null,
  "themeCustomName": "Colourpop/Main",
  "appsDetected": [
    "Klaviyo",
    "Attentive",
    "Yotpo",
    "Okendo",
    "Nosto"
  ],
  "appCount": 14,
  "appCategories": [
    "Email & SMS",
    "Reviews & loyalty",
    "Reviews",
    "Personalization",
    "Search"
  ],
  "productsSampled": 500,
  "priceMin": 5,
  "priceMedian": 12,
  "priceMax": 159,
  "productsOnSalePct": 0,
  "productsAvailablePct": 96,
  "topVendors": [
    "ColourPop",
    "Fourth Ray Beauty",
    "SOL Body"
  ],
  "topProductTypes": [
    "Ultra Glossy Lip",
    "Full Collection Set",
    "Super Shock Shadow",
    "Hyper Shine Glossy Lipstick",
    "Shadow Palette"
  ],
  "topTags": [
    "Lips",
    "Collab",
    "lip-gloss",
    "new-arrival",
    "vegan"
  ],
  "lastProductPublishedAt": "2026-10-08T16:37:18.000Z",
  "lastProductUpdatedAt": "2026-10-09T13:09:11.000Z",
  "daysSinceLastProductUpdate": 0,
  "newProductsLast30Days": 85,
  "productCount": 1061,
  "productsSampleComplete": false,
  "topCollections": [
    "The 25% OFF Edit",
    "Promotional",
    "Singles",
    "Shop All ColourPop",
    "Core Assortment"
  ],
  "emails": [],
  "phones": [],
  "socials": {
    "instagram": "https://www.instagram.com/colourpopcosmetics",
    "tiktok": "https://www.tiktok.com/@colourpopco",
    "x": "https://x.com/colourpopco"
  },
  "instagram": "https://www.instagram.com/colourpopcosmetics",
  "facebook": null,
  "tiktok": "https://www.tiktok.com/@colourpopco",
  "x": "https://x.com/colourpopco",
  "youtube": null,
  "pinterest": null,
  "linkedin": null,
  "contactEmail": null,
  "contactPhone": null,
  "errors": {},
  "checkedAt": "2026-10-09T13:13:40.781Z"
}
```

### Pricing

Pay per event, no subscription:

| Event | Price |
|---|---|
| Actor start | $0.00005 per run |
| Store analyzed (live Shopify store returned) | **$0.004** |
| Product row (only if "Also output products" is on) | $0.0005 |

**Worked example:** 1,000 domains, 600 of them are Shopify: 600 x $0.004 = **$2.40**. The 400 non-Shopify rows are free. Add products for 100 stores at 100 products each: 10,000 x $0.0005 = $5.00. Set a max charge per run in the run options and the actor stops cleanly at that limit.

Apify's free plan includes $5 of monthly platform credit, which covers about 1,000 store analyses with this actor (at $0.004 per result, plus small platform usage).

### Use cases

- Shopify app and agency sales: find stores and see which apps they already use.
- Niche research: discover stores by keyword and compare catalogs and price ranges.
- Ecommerce investors: screen stores by catalog size and activity.
- Outreach: store contacts (role emails, phones, socials) in the same row.

### Use from AI agents (MCP, ChatGPT, Claude, Perplexity)

Shopify Store Leads works as a tool for AI assistants through the official Apify MCP server. Add this server URL to any MCP client (Claude Desktop, Claude Code, Cursor, ChatGPT connectors, VS Code):

```
https://mcp.apify.com/?actors=transparent_meteorite/shopify-store-leads
```

Claude Desktop / Cursor config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=transparent_meteorite/shopify-store-leads",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Then ask in plain language, for example: "How do I find Shopify stores in a niche with contact emails?"

Call it directly over HTTP (runs the actor and returns the dataset items in one request):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~shopify-store-leads/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["allbirds.com", "brooklinen.com", "colourpop.com", "deathwishcoffee.com", "kyliecosmetics.com"], "keywords": [], "maxStores": 5, "includeProducts": false}'
```

Python:

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("transparent_meteorite/shopify-store-leads").call(run_input={"domains": ["allbirds.com", "brooklinen.com", "colourpop.com", "deathwishcoffee.com", "kyliecosmetics.com"], "keywords": [], "maxStores": 5, "includeProducts": false})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

The same actor works in n8n, Make, Zapier, LangChain, LlamaIndex and CrewAI through their Apify integrations.

#### Questions people ask

**How do I find Shopify stores in a niche with contact emails?**
Put niche words in keywords (or your own domain list in domains); each store row includes emails, phones and socials found on the store.

**Can I see which apps a Shopify store uses?**
Yes, it detects 60+ apps such as Klaviyo, Yotpo and ReCharge from the public storefront.

**Does it estimate revenue?**
No, only facts visible on the store.

### Use it from code

Small real input: it returns only a couple of rows, so a test run costs very little (see Pricing). Set the `APIFY_TOKEN` environment variable to your token from [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations).

**Python** (`pip install apify-client`)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run_input = {'domains': ['allbirds.com'], 'maxStores': 1, 'includeProducts': False}
run = client.actor("transparent_meteorite/shopify-store-leads").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript / Node.js** (`npm install apify-client`)

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  "domains": [
    "allbirds.com"
  ],
  "maxStores": 1,
  "includeProducts": false
};
const run = await client.actor('transparent_meteorite/shopify-store-leads').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**curl** (runs the actor and returns the dataset items in one call)

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~shopify-store-leads/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["allbirds.com"], "maxStores": 1, "includeProducts": false}'
```

### Send results to Google Sheets, Zapier, Make or n8n

- **Google Sheets:** every run's dataset has a CSV export link: `https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&clean=true` (the dataset ID is on the run's Storage tab). In Sheets, `=IMPORTDATA("<that link>")` loads it. Anyone with the link can read that dataset, so share it carefully. To export to Google Drive automatically, use the Google Drive integration on the actor's Integrations tab.
- **Zapier:** in the Apify app, use the trigger **Finished Actor run** (or **Run Actor** as an action) with `transparent_meteorite/shopify-store-leads`, then **Fetch dataset items** and pass the rows to Google Sheets, a CRM or Slack.
- **Make:** the Apify app has **Watch Actor Runs**, **Run an Actor** and **Get Dataset Items** modules; connect them to any Make app.
- **n8n:** install the Apify node (`@apify/n8n-nodes-apify`) and use **Run an Actor and get dataset**, or the **On new Apify event** trigger.
- **Schedule and webhooks:** create a Task with your input, add a Schedule in Apify Console, and add a webhook if you want a call when a run finishes.

See the [Apify integrations docs](https://docs.apify.com/platform/integrations) for setup steps.

### Integrations

**API (curl)**

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~shopify-store-leads/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains":["allbirds.com","colourpop.com"]}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("transparent_meteorite/shopify-store-leads").call(run_input={"keywords": ["candles"], "maxStores": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["storeName"], item.get("contactEmail"), item.get("appsDetected"))
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('transparent_meteorite/shopify-store-leads').call({ domains: ['brooklinen.com'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**No-code:** Make, Zapier and n8n (Apify app / node), Google Sheets export, webhooks on run success, and Apify **schedules** to re-check a store list weekly and catch new apps or catalog changes.

New to Apify? [Create a free account](https://console.apify.com/sign-up?fpr=rnmakg) and run this Actor in under a minute. Some links are affiliate links.

### Related actors

More tools from the same publisher that fit this workflow:

- [Amazon Product Search](https://apify.com/transparent_meteorite/amazon-product-search): search Amazon for prices, ratings and ASINs
- [Amazon Best Sellers Scraper](https://apify.com/transparent_meteorite/amazon-bestsellers): best seller ranks across 21 Amazon countries
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain): enrich a domain with socials, emails and tech stack
- [Website Email Extractor](https://apify.com/transparent_meteorite/website-contact-extractor): pull emails, phones and socials from each business website
- [Website Tech Stack Detector](https://apify.com/transparent_meteorite/website-tech-stack-detector): detect the CMS, frameworks and hosting behind any site
- [Local Business Leads](https://apify.com/transparent_meteorite/local-business-leads): find local businesses with no website from OpenStreetMap, a cheap complement to Maps data

Use from AI agents: every actor here is callable through the Apify MCP server (mcp.apify.com) and our open-data-actors MCP endpoint.

### FAQ

#### Where do the Shopify leads come from?

From your own `domains` list, or from niche `keywords` matched against store names in the public Common Crawl URL index. Each store is then checked live on its public storefront.

#### Do Shopify leads include emails?

When the store publishes them: the emails, phones and social links shown on its storefront and contact page. Not every store lists an email.

#### Is this legal?

It reads only public, unauthenticated storefront endpoints that Shopify serves to every visitor (`/`, `/meta.json`, `/products.json`, `/collections.json`, `/pages/contact`) and the public Common Crawl index. No login, no captcha bypass, no proxies, no search-engine scraping. Contacts are limited to business details the store publishes. You are responsible for how you use the data (for example CAN-SPAM / GDPR rules for outreach).

#### How is Shopify detected?

Any of: a valid `/meta.json` with a `*.myshopify.com` domain, Shopify response headers, `cdn.shopify.com` assets, or the `Shopify.shop` variable. `detectionSignals` lists which ones matched.

#### Am I charged for domains that are not Shopify?

No. Non-Shopify sites, closed or password-protected stores, duplicates and malformed input are free.

#### How does discovery find stores?

It searches the newest Common Crawl monthly URL indexes for `*.myshopify.com` hosts whose name contains your keyword, then analyzes each. Stores whose myshopify name doesn't contain the keyword won't be found this way, so combine discovery with your own domain lists for full coverage.

#### Why is a field empty?

Some large stores block `/products.json` or `/meta.json`, or publish no email. The row still returns, with the reason in `errors`.

#### Which apps are detected?

60+ including Klaviyo, Omnisend, Attentive, Postscript, Privy, Yotpo, Judge.me, Okendo, Stamped, Loox, Junip, Smile.io, LoyaltyLion, ReCharge, Skio, Bold, Rebuy, Nosto, Searchanise, Boost, Algolia, Gorgias, Zendesk, Tidio, Afterpay, Klarna, Affirm, Sezzle, Route, AfterShip, Loop Returns, Global-e, Weglot, Shogun, PageFly, GemPages, Triple Whale, Elevar, Hotjar, Meta/TikTok/Pinterest/Snap pixels. Detection reads the homepage, so apps loaded only on product or checkout pages may be missed.

#### How many products are read?

Up to 500 per store for the summary (`productsSampled`, `productsSampleComplete`). `productCount` comes from the store's own published count. With products output on, up to `maxProductsPerStore` rows per store.

### More questions

**How do I find Shopify stores in a niche?**
Use `keywords`; the actor discovers candidate stores and checks each one. Or pass your own `domains`.

**Can I see which apps a Shopify store uses?**
Yes, apps that leave a public footprint on the storefront.

**Does it estimate revenue or traffic?**
No.

**Am I charged for domains that are not Shopify?**
See the Pricing and FAQ sections above; `includeNonShopify` controls whether non-Shopify domains appear in the output.

### How this compares

Ecommerce intelligence platforms keep store databases with revenue and traffic estimates; this actor does not estimate either. It checks stores live from their public storefront and products.json, and you pay per store analyzed.

### Limits

- Homepage-based app detection (no checkout or product-page scripts).
- Stores that rate-limit or block bots (HTTP 429 / 403) return a row with `errors` filled.
- Discovery depends on Common Crawl coverage and on the keyword appearing in the myshopify subdomain; Common Crawl can be slow or briefly unavailable (the actor retries with backoff).
- Contacts are only what the store publishes on its homepage and contact page.

### Reliability

Last 30 days, measured from Apify run records (all runs, including our own daily health checks): **20 of 20 finished runs succeeded (100.0%)**, median run time **4.4 s** (90th percentile 10.4 s). Aborted runs (0) are not counted.

Updated 2026-10-11 automatically every week from the run history. Report any failure on the Issues tab with the run URL.

### More resources

- Guide & examples: [mamoo85.github.io/open-data-actors/shopify-store-leads.html](https://mamoo85.github.io/open-data-actors/shopify-store-leads.html)
- Sample output and example input on GitHub (masked sample CSV): [github.com/Mamoo85/apify-actor-samples/shopify-store-leads](https://github.com/Mamoo85/apify-actor-samples/tree/main/shopify-store-leads)

### Changelog

- 2026-10-07: Launched: Shopify detection, apps, theme, catalog stats, contacts and keyword discovery.
- 2026-10-09: Output tab table view.
- 2026-10-09: Input sections, status messages, examples.
- 2026-10-09: Branding: maintained by Detroit Web Agent - Open Data.
- 2026-10-13: Added a Run in 30 seconds section with a one-click prefilled run link, saved use-case presets, cross-links to pairing actors and Store title and search description reworded around how buyers search.
- 2026-10-13: v0.2: category, location and price filters, new-stores-only monitor mode, sample products, review rating and count, empty-input demo run.

### Support

Found a wrong detection or want an app fingerprint added? Open an issue on the actor's **Issues** tab with the domain, and we'll fix it quickly.

### Works well with

Other actors from Detroit Web Agent - Open Data that pair with this one:

- [Website Tech Stack Detector](https://apify.com/transparent_meteorite/website-tech-stack-detector): for non-Shopify sites in your list: the full technology lookup.
- [Website Contact Extractor](https://apify.com/transparent_meteorite/website-contact-extractor): deeper contact crawl for the stores you shortlist.
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain): company-level details for the same domains.
- [Meta Ad Library](https://apify.com/transparent_meteorite/meta-ad-library): see which companies are running Meta ads alongside their news and store data.
- [Amazon Product Search](https://apify.com/transparent_meteorite/amazon-product-search): Amazon search results and prices next to Shopify store and app data.
- [Sitemap Link Inventory](https://apify.com/transparent_meteorite/sitemap-link-inventory): list every product and collection URL on a store you are researching.

### What the free plan gets you

Free plan: about 1,250 analyzed stores from your $5 monthly Apify credit (at $0.004 each, today's price); default settings return about 1 row (one sample store; add more domains to scale). Optional product rows cost $0.0005 each when you switch them on. Need more? Upgrade your Apify plan or set a higher result limit in the input.

### Need more than the data?

This actor is built by [Detroit Web Agent](https://www.detroitwebagent.com/?utm_source=apify\&utm_medium=readme\&utm_campaign=shopify-store-leads), a small Detroit studio that builds websites, lead pages and simple data tools for small businesses. If you want these results turned into a working website, a landing page or a CRM import, or you need a field this actor does not cover yet, open an issue on the Issues tab or visit [detroitwebagent.com](https://www.detroitwebagent.com/?utm_source=apify\&utm_medium=readme\&utm_campaign=shopify-store-leads).

***

Built and maintained by **Detroit Web Agent - Open Data** (Detroit, Michigan). Questions, bugs or a field you need: open an issue on this Actor's Issues tab and we will reply there.

# Actor input Schema

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

Websites to check, one per row (for example allbirds.com or https://www.brooklinen.com/collections/all). Each is tested for Shopify; Shopify stores get a full profile. Non-Shopify sites return a free row with isShopify=false.

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

Optional. Niche words such as 'coffee roaster', 'candles' or 'dog treats'. Finds \*.myshopify.com stores whose store name contains the keyword in the public Common Crawl URL index, then analyzes each one. Leave empty to only analyze the domains above.

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

Cap on stores analyzed (and charged) this run, across given domains and discovered stores.

## `crawls` (type: `integer`):

How many of the newest monthly Common Crawl indexes to search per keyword. More snapshots find more stores but take longer.

## `includeProducts` (type: `boolean`):

Add one row per product (title, URL, vendor, type, tags, price range, compare-at price, availability, variants, SKUs, image, dates) from /products.json. Charged per product row.

## `maxProductsPerStore` (type: `integer`):

Cap on product rows per store when 'Also output products' is on. Store summaries always use up to 500 products.

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

Keep a free row (isShopify=false) for domains that are not Shopify or are closed, so you can filter a mixed list. Never charged.

## `category` (type: `array`):

Optional. Only keep (and charge for) stores whose name, description, collections, product types, tags or vendors contain one of these words, e.g. 'coffee', 'skincare', 'sneakers'. Leave empty for no category filter. Filtered-out stores are free.

## `storeLocation` (type: `array`):

Optional. Only keep stores based in these countries, provinces or cities: two-letter codes (US, GB, CA) or names (Canada, Texas, London). Uses the location the store publishes. Filtered-out stores are free.

## `priceMin` (type: `integer`):

Optional. Only keep stores whose median product price (store currency) is at least this value. Filtered-out stores are free.

## `priceMax` (type: `integer`):

Optional. Only keep stores whose median product price (store currency) is at most this value. Filtered-out stores are free.

## `skipPreviouslyScraped` (type: `boolean`):

Remember every store this actor has delivered (in a named key-value store 'shopify-store-leads-state') and skip them next time, so scheduled runs return only new leads. Skipped stores are not charged.

## `includeRatings` (type: `boolean`):

Read one product page per store to capture the aggregate star rating and total product reviews (JSON-LD or Judge.me markup). Adds one request per store; turn off for the fastest run.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com"
  ],
  "keywords": [],
  "maxStores": 1,
  "crawls": 2,
  "includeProducts": false,
  "maxProductsPerStore": 250,
  "includeNonShopify": true,
  "category": [],
  "storeLocation": [],
  "skipPreviouslyScraped": false,
  "includeRatings": true
}
```

# Actor output Schema

## `stores` (type: `string`):

No description

## `products` (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 = {
    "domains": [
        "allbirds.com"
    ],
    "maxStores": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/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": ["allbirds.com"],
    "maxStores": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/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": [
    "allbirds.com"
  ],
  "maxStores": 1
}' |
apify call transparent_meteorite/shopify-store-leads --silent --output-dataset

```

## MCP server setup

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