# Shopify Store Finder — Target by Size & Tech Stack (`cool_jacquard/shopify-store-enrichment`) Actor

Find Shopify stores by installed apps (Klaviyo, Recharge, Gorgias, Yotpo, Loox), product count and country. Targeted B2B lead generation: enriched, revenue-qualified Shopify leads with email and socials — not a raw domain dump. Pay only for stores matching your filters.

- **URL**: https://apify.com/cool_jacquard/shopify-store-enrichment.md
- **Developed by:** [Pavel Bragin](https://apify.com/cool_jacquard) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$8.00 / 1,000 enriched store rows

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 Finder — Target by Size & Tech Stack

**Find the Shopify stores you actually want to sell to — not a raw domain dump.** Filter live stores by size, installed apps and country, and get back enriched, revenue-qualified leads with contacts. Prospect with a scalpel, not a firehose.

Two ways to use it:

- **Discover mode** — set *Seed from Common Crawl* and the actor finds stores for you, then keeps only the ones matching your filters. No input list needed.
- **Enrich mode** — paste your own domains and get them enriched, Shopify-verified and filtered.

### Why this beats a raw "Shopify leads" list

Other lists hand you thousands of domains and let you sort out the noise. This one **filters to your ideal customer before you pay**:

- **Target by size** — `minProducts` / `maxProducts`. Reach established stores, or deliberately hunt small/mid shops instead of enterprises. Store size (`products_count`) is a real revenue signal most lists don't expose.
- **Target by tech stack** — `requireApps` / `excludeApps`. Find every store running **Klaviyo** (sell them a Klaviyo add-on), or every store *not* running a review app (whitespace for your review tool). Detected apps: Klaviyo, Recharge, Gorgias, Yotpo, Judge.me, Loox, Okendo, Attentive and more.
- **Target by geography** — `countries` (US, GB, DE…).
- **Reach them** — contact `email` + `socials` included.

Non-Shopify, dead domains, and stores that don't match your filters are **never charged**. You pay only for verified leads that fit.

### Example: prospecting recipes

- *"Mid-size US fashion stores on Klaviyo"* → `minProducts: 50`, `countries: ["US"]`, `requireApps: ["Klaviyo"]`
- *"Stores that don't use a review app yet"* → `excludeApps: ["Yotpo", "Judge.me", "Loox", "Okendo"]`
- *"Small stores to onboard"* → `maxProducts: 100`

### Who uses it

- **Agencies & freelancers** prospecting Shopify merchants for design, CRO, email or ads
- **App & SaaS vendors** building lists by installed-app footprint
- **3PL / fulfillment / logistics** targeting stores of a given size
- **Market researchers** sizing a niche or geography

### Output

One row per verified store:

| Field | Example |
|---|---|
| `domain` | `007airsoft.com` |
| `name` | `007 Airsoft Ltd.` |
| `myshopify_domain` | `007airsoft.myshopify.com` |
| `country` / `city` | `CA` / `Calgary` |
| `products_count` | `2151` |
| `collections_count` | `48` |
| `currency` | `CAD` |
| `apps` | `["Klaviyo", "Recharge"]` |
| `socials` | `{"instagram": "instagram.com/…"}` |
| `email` | `hello@…` |

Export to CSV, Excel, JSON, or pull via the Apify API into your CRM.

### Input

**Discover a directory (no list needed):**

```json
{
    "seedFromCommonCrawl": 5,
    "maxDomains": 5000,
    "minProducts": 5,
    "enrich": true
}
```

`seedFromCommonCrawl` = how many Common Crawl pages to harvest (~1,800 stores per page).

**Enrich your own domains:**

```json
{
    "domains": ["gymshark.com", "allbirds.com"],
    "enrich": true
}
```

### Pricing

Pay per store row returned. Dead domains, non-Shopify sites and duplicates are free. You only pay for verified, enriched stores.

### FAQ

**Where does the data come from?** Public Shopify storefront endpoints (`/meta.json`, `/products.json`) and the public [Common Crawl](https://commoncrawl.org/) web index. No login, no private data.

**Is it complete?** Directory mode samples the Common Crawl index — increase `seedFromCommonCrawl` for broader coverage. Coverage grows as you raise the page count.

**Can I refresh it?** Yes — re-run any time. Common Crawl publishes a fresh index monthly, so new stores appear over time.

# Actor input Schema

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

Optional: enrich a specific list of store domains you already have (e.g. gymshark.com). If you fill this in, auto-discovery is skipped and only these are processed. Leave empty to build a directory from Common Crawl (default).

## `seedFromCommonCrawl` (type: `integer`):

How many Common Crawl pages of live Shopify stores to discover (~1,800 stores per page). Used when you don't supply your own domains. Raise for a bigger directory.

## `seedIndexes` (type: `integer`):

For a FULL directory: sweep this many monthly Common Crawl indexes with shared dedup, stopping automatically when newer indexes stop adding stores. ~15-18k stores per index; overlap grows with each older index. 0 = use single-index / seedFromCommonCrawl instead.

## `maxDomains` (type: `integer`):

Hard cap on how many discovered stores to process. Raise this for a bigger directory (e.g. 50000).

## `enrich` (type: `boolean`):

Also scrape the homepage for tech stack (Klaviyo, Recharge…), social links and contact email.

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

Only keep stores with at least this many published products. Filters out empty/hobby shops so you target real businesses.

## `maxProducts` (type: `integer`):

Only keep stores with at most this many products — e.g. target small/mid stores, not enterprises. 0 = no ceiling.

## `requireApps` (type: `array`):

Only keep stores running at least one of these apps (e.g. Klaviyo, Recharge, Gorgias, Yotpo, Judge.me, Loox, Attentive). Great for finding users of a tool you integrate with or compete against. Enrichment is auto-enabled.

## `excludeApps` (type: `array`):

Skip stores already running one of these apps — e.g. find stores that do NOT yet use your category of tool (whitespace prospecting).

## `countries` (type: `array`):

Only keep stores in these countries (ISO codes, e.g. US, GB, DE). Empty = all.

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

How many domains to check in parallel.

## Actor input object example

```json
{
  "domains": [],
  "seedFromCommonCrawl": 3,
  "seedIndexes": 0,
  "maxDomains": 10000,
  "enrich": true,
  "minProducts": 0,
  "maxProducts": 0,
  "requireApps": [],
  "excludeApps": [],
  "countries": [],
  "concurrency": 10
}
```

# Actor output Schema

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

Enriched, filter-matched Shopify stores with size, tech stack and contacts.

## `storesCsv` (type: `string`):

The same directory as a CSV file, ready for your CRM or spreadsheet.

# 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": [],
    "requireApps": [],
    "excludeApps": [],
    "countries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("cool_jacquard/shopify-store-enrichment").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": [],
    "requireApps": [],
    "excludeApps": [],
    "countries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("cool_jacquard/shopify-store-enrichment").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": [],
  "requireApps": [],
  "excludeApps": [],
  "countries": []
}' |
apify call cool_jacquard/shopify-store-enrichment --silent --output-dataset

```

## MCP server setup

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

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/c3RpJjljs7GABAHKV/builds/cXm1eJx1tabYsXoxU/openapi.json