# Shopify Store Leads - Find Stores by Niche + Email & Products (`that_red_bird/shopify-store-leads-finder`) Actor

Find Shopify stores in any niche, with contact email, socials, product count, price range and sample products. Each store is verified live against its own catalogue, not a category label. For app makers, agencies and suppliers. $0.003 per store.

- **URL**: https://apify.com/that_red_bird/shopify-store-leads-finder.md
- **Developed by:** [mohamed alaya](https://apify.com/that_red_bird) (community)
- **Categories:** Lead generation, E-commerce, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 store founds

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 - Find Stores by Niche + Email & Products

Type a niche like "pet supplies" and get Shopify stores that really sell it, each with a contact email, socials, product count, price range and the apps it runs.
Niche -> verified Shopify stores in about 2 minutes. Every store is checked live against its own product catalogue, not a category label.

Built for Shopify app makers, ecommerce agencies, suppliers and wholesalers who need a list of real stores to contact.

### What you get

| Field | Meaning |
|---|---|
| `store`, `name`, `myshopifyDomain` | The store's web address, its name and its `.myshopify.com` address |
| `email`, `otherEmails`, `phone`, `contactPageUrl` | Contact details printed on the homepage or contact page (no guessing) |
| `instagram`, `facebook`, `tiktok`, `youtube`, `x`, `linkedin` | Social links found on the store |
| `country`, `city`, `currency` | What the store reports about itself |
| `productCount` | Number of published products |
| `priceMin`, `priceMedian`, `priceMax` | Price range across the catalogue (store's own currency) |
| `vendors`, `productTypes` | The brands and product types it sells most |
| `nicheMatchPercent`, `matchedProducts` | How much of the catalogue matches your niche, plus three matching products |
| `sampleProducts` | Three products from the catalogue, with price and link |
| `oldestProductAt`, `lastProductPublishedAt`, `activeRecently` | Age and activity hints: a store that published a product in the last 4 months is "active" |
| `theme`, `apps` | Shopify theme and apps detected on the homepage (Klaviyo, Judge.me, Yotpo, Gorgias, Recharge, Meta Pixel ...) |

### 3 ways to use it

1. **Find stores in a niche.** Small and quick, good for a first look.
   `{"niche": "pet supplies", "maxStores": 10}`
2. **Serious stores only, with an email.** Skips hobby stores and stores with no contact.
   `{"niche": "organic skincare", "minProducts": 20, "requireEmail": true, "maxStores": 100}`
3. **Enrich a list you already have.** Paste store websites; each is checked and filled in. Your stores are never filtered by niche.
   `{"storeUrls": ["allbirds.com", "gymshark.com"], "minProducts": 0}`

### Input

| Field | What to enter | Default |
|---|---|---|
| Niche | What the stores sell, in plain words | pet supplies |
| Store URLs | Optional list of stores to enrich instead of searching | empty |
| Max stores | Stop after N stores that pass your filters (also your spending cap) | 10 |
| Minimum products | Skip small stores. 20 or more skips hobby stores | 5 |
| Minimum / maximum typical price | Median product price range, whole units of the store's currency. 0 = off | 0 |
| Minimum niche match (%) | Share of the catalogue (first 250 products) that must match the niche | 10 |
| Store country | Two-letter code such as US, GB, DE. Empty = any | empty |
| Only stores with an email | Drop stores where no email was found | off |
| Only new stores since last run | Remembers stores already checked for this niche and continues the search where the last run stopped. Use for weekly runs | off |
| Time limit (minutes) | 0 = automatic: 4 minutes, plus a little more for every store above 10 | 0 |

An empty input works: it looks for "pet supplies" stores and returns up to 10.

### Output example

```json
{
  "store": "https://06bd8c.myshopify.com",
  "name": "Pets Warehouse",
  "country": "US",
  "city": "Lindenhurst",
  "currency": "USD",
  "email": "info@petswarehouse.com",
  "phone": "+1-631-842-1230",
  "instagram": "https://instagram.com/petswarehouse",
  "productCount": 17713,
  "priceMin": 2.99,
  "priceMedian": 40.99,
  "priceMax": 630.99,
  "vendors": ["Friskies", "Blue Buffalo", "Nestle Purina Petcare Company"],
  "nicheMatchPercent": 75,
  "matchedProducts": [{"title": "Synergy Labs Dental Fresh Water Additive For Dogs & Cats 17 oz", "price": 19.99}],
  "activeRecently": true,
  "apps": ["Trustpilot", "Shopify Inbox"]
}
```

### Pricing (pay per event)

| Event | Price |
|---|---|
| Store found (a verified Shopify store that passes your filters) | $0.003 |

- 10 stores -> **$0.03**
- 300 stores -> **$0.90**
- Stores that fail your filters, closed stores and non-Shopify sites are checked for free: you pay only for stores delivered.
- Compare: other Shopify lead Actors charge about $0.006 per lead.

### Use it with

- **Before:** your own list of competitor or prospect websites -> **this Actor** with "Store URLs".
- **After:** this Actor -> Lead List Deduplicator -> your CRM, Instantly or Lemlist.
- Make, Zapier and n8n: run weekly, send new stores to Google Sheets or HubSpot.
- **AI agents / MCP:** call `that_red_bird/shopify-store-leads-finder` with `{"niche": "yoga mats", "maxStores": 20}`.

### FAQ

- **How are stores found?** From public indexes that need no login (the Internet Archive's index of `.myshopify.com` pages that mention your niche). Every candidate is then opened and must prove it is a live Shopify store with products matching your niche.
- **Is this every store in the niche?** No. Public indexes only know a share of all stores, and results lean towards stores that publish under their `.myshopify.com` address. For a complete picture, combine this with your own URL lists. It is a way to get a few hundred real, checked leads cheaply, not a full database.
- **Why is the email missing?** Many stores show only a contact form. You still get `contactPageUrl` and the socials.
- **Are the product counts exact?** Usually yes: most stores publish their size. When a store does not, the count comes from the first pages of its public catalogue and may stop at 1,000.
- **Is this legal?** It reads only public store pages and public catalogue files. You are responsible for GDPR, CAN-SPAM and local rules when you contact stores.
- **Can I run it every week?** Yes. Turn on "Only new stores since last run" and schedule it: each run carries on where the previous one stopped, so you get new stores instead of the same ones.

### Limits

- Discovery depends on a public index that is sometimes slow or busy. Broad niches (pets, fashion, jewelry, coffee) work best; very narrow niches may return only a few stores. Coverage is partial. Use "Store URLs" for exact targets, and "Only new stores" to dig deeper over several runs.
- If no public index answers from the server, a short built-in list of well-known Shopify stores is checked instead and those rows are marked `discoveredVia: "built-in-sample"`.
- Stores that password-protect their catalogue or turn off the public product feed return fewer fields.
- No revenue, traffic or ad-spend data: those are not public.
- Apps and theme are detected from the homepage code only, so back-end apps that leave no trace on the page are not listed.

### Support

Open an issue on the Issues tab, we answer within 24 hours. If this saved you time, a short review helps other people find it.

# Actor input Schema

## `niche` (type: `string`):

What the stores sell, in plain words: 'pet supplies', 'organic skincare', 'yoga mats'. Stores are kept only if their own product catalogue matches these words.

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

Optional. Paste store websites to check and enrich instead of searching, one per line. Stores you list are never filtered by niche (but are still checked to be Shopify stores).

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

Stop after this many stores that pass your filters. You pay per store delivered, so this is also your spending cap.

## `minProducts` (type: `integer`):

Skip stores with fewer products than this. Use 20 or more to skip hobby stores. Use 0 to keep every store.

## `minPrice` (type: `integer`):

Skip stores whose median product price is below this (in the store's own currency, whole units). 0 means no minimum.

## `maxPrice` (type: `integer`):

Skip stores whose median product price is above this (in the store's own currency, whole units). 0 means no maximum.

## `minNicheMatchPercent` (type: `integer`):

Share of the store's products (first 250 read) that must match your niche words. 10 keeps focused stores and drops general ones. Use 0 to accept any store with at least one match.

## `country` (type: `string`):

Two-letter country code the store reports about itself, for example US, GB, DE, CA. Leave empty for any country. Stores that do not publish a country are skipped when this is set.

## `requireEmail` (type: `boolean`):

Keep only stores where a contact email was found on the site. Stores that are skipped are not charged.

## `onlyNewStores` (type: `boolean`):

Remember the stores already checked for this niche (in your own account) and carry on searching where the last run stopped, so every run brings different stores. Use it for weekly runs.

## `maxRunMinutes` (type: `integer`):

Stop searching after this many minutes and return what was found. 0 means automatic: 4 minutes plus a little more for every store above 10.

## `concurrency` (type: `integer`):

How many different stores are checked at the same time. Each store is always read gently, a few pages at a time.

## Actor input object example

```json
{
  "niche": "pet supplies",
  "storeUrls": [],
  "maxStores": 10,
  "minProducts": 5,
  "minPrice": 0,
  "maxPrice": 0,
  "minNicheMatchPercent": 10,
  "country": "",
  "requireEmail": false,
  "onlyNewStores": false,
  "maxRunMinutes": 0,
  "concurrency": 4
}
```

# Actor output Schema

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

No description

## `downloadCsv` (type: `string`):

No description

## `summary` (type: `string`):

No description

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("that_red_bird/shopify-store-leads-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call that_red_bird/shopify-store-leads-finder --silent --output-dataset

```

## MCP server setup

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

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/MThWKVlK11lYMqvN1/builds/GafXiqPVCWT2FYU05/openapi.json