# E-commerce Store Finder — Shopify & WooCommerce Stores by Niche (`inovaflow/ecommerce-store-finder`) Actor

Find Shopify, WooCommerce, BigCommerce, Magento, Wix and Squarespace stores in any niche, verified on the storefront itself: platform, product count, currency, country, apps, payment providers, pixels and contacts. No login, dataset-only, MCP-ready.

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

## Pricing

from $20.00 / 1,000 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

If you sell to online stores — apps, agencies, fulfilment, payments, packaging, insurance — your prospect list is "every Shopify / WooCommerce / BigCommerce store in my niche", and the lists you can buy are stale indexes. **E-commerce Store Finder** builds that list live: type a niche (`candles`, `yoga apparel`, `dog treats`), and get back stores that were **verified on their own storefront at run time** — platform with evidence, product count, currency, country, the apps and payment providers they run, sample products, and the emails and social profiles from their site.

- **Shopify / e-commerce app vendors** — every store in your category with the apps it already uses (Klaviyo, Yotpo, Judge.me, Recharge, Gorgias …) and its catalogue size.
- **Agencies & freelancers** — small and mid-size stores on the platform you build for, with a contact.
- **3PL, packaging, payments, BNPL** — stores by niche and country, with product count bands and the payment providers on the checkout.
- **Founders & researchers** — a market map of a niche across six platforms, deduplicated by domain.

### What does E-commerce Store Finder do?

It is a **Shopify and WooCommerce store finder** (plus BigCommerce, Magento, Wix Stores and Squarespace Commerce). For each niche and platform it runs web searches (Google through the Apify SERP proxy, with Bing and DuckDuckGo as fallbacks), turns the results into candidate shops, then **reads each shop itself**: Shopify's public `/meta.json`, `/products.json` and product sitemaps (exact product count, currency, country, vendors), WooCommerce's public Store API (`/wp-json/wc/store/v1/products`, exact count from `X-WP-Total`), and the storefront HTML for the other platforms (fingerprints, JSON-LD currency). Every row carries the evidence it was verified with. Sites that are not a store, demo shops on platform subdomains, duplicates and unreachable hosts are dropped and never charged. No login, no API key, no browser.

### Why use this store finder?

- **Verified, not indexed.** A row exists only because the storefront answered — product counts come from the store's own catalogue endpoint, never from an estimate.
- **Six platforms in one run**, one row per store domain even when a shop is reachable on its `myshopify.com` host and its custom domain.
- **Sales-ready columns:** apps, payment providers (Shop Pay, PayPal, Klarna, Afterpay, Apple Pay …), marketing pixels (GA4, Meta, TikTok …), size band, currency, country, sample products, emails, phones, socials.
- **Paste a list to enrich.** Give it store domains instead of niches and it verifies and enriches them the same way.
- **Fair pricing you can predict.** $0.02 per verified store, $0.01 more **only when a contact was found**; filtered, duplicate and non-store candidates cost nothing.
- **Runs anywhere.** Schedule weekly niche refreshes, call it from the API, from Zapier / Make / n8n, or from an AI agent through MCP.

### What data does it extract?

| Field | Description |
| --- | --- |
| `storeName`, `domain`, `url` | Store name (Shopify's own name where available) and canonical domain (the row key) |
| `platform`, `platformLabel`, `platformConfidence`, `platformEvidence` | `shopify`, `woocommerce`, `bigcommerce`, `magento`, `wix`, `squarespace`; 100 = verified through the catalogue endpoint, 80–95 = HTML/header/cookie fingerprint; the evidence strings |
| `productCount`, `productCountBand` | Exact published-product count (Shopify: product sitemaps; WooCommerce: `X-WP-Total`), `null` where the platform does not publish it; band `1-9` … `5000+` |
| `currency`, `country` | Store currency and ISO country (Shopify `/meta.json`, WooCommerce Store API, JSON-LD / locale / ccTLD otherwise) |
| `apps`, `paymentProviders`, `marketingTech` | Storefront apps, payment providers and pixels detected on the homepage |
| `vendors`, `productCategories`, `sampleProducts` | Shopify vendors / product types, WooCommerce categories; up to 5 sample products with URL and price |
| `emails`, `primaryEmail`, `phones`, `socials` | From the homepage + contact / about pages (same-domain role addresses first) |
| `instagramFollowers` | Only when a follower count is literally printed on the store page |
| `contactStatus` | `ok`, `no_contacts`, `unreachable`, `skipped` |
| `niche`, `niches`, `myshopifyDomain`, `title`, `description`, `evidence`, `sources`, `scrapedAt` | Provenance |

### How to find Shopify and WooCommerce stores by niche

1. Open the Actor and click **Try for free**.
2. Under **Niches / keywords** type one niche per line, e.g. `candles`, `yoga apparel`, `Bio Hundefutter`.
3. Pick the **Platforms** (all six by default) and optionally **Countries** (`US`, `GB`, `DE` …) and a **Minimum product count**.
4. Set **Max stores** (default 50). Click **Start** — verified stores stream into the **Output** tab; a 20-store run takes about two minutes.
5. Export as **CSV, Excel, JSON** or open `STORES.csv` and import it into HubSpot, Pipedrive, Lemlist, Instantly or Google Sheets.

#### How to verify and enrich a list of store domains

Paste the domains into **Store domains to verify** and leave **Niches** empty. Each domain is fetched, fingerprinted and enriched exactly like a discovered store; sites that are not a store are reported in the run summary and never charged.

### How much does it cost to find e-commerce stores?

| Event | Price |
| --- | --- |
| Verified store delivered | **$0.02** |
| Contact found (≥ 1 email or social profile) | **$0.01** |
| Actor start | $0.005 per GB |

A 20-store niche run with contacts costs about **$0.50**; 1,000 fully enriched stores ≤ **$30**. Duplicates, candidates that are not a store, unreachable sites and stores removed by your filters are never charged. See [PRICING.md](PRICING.md).

### Input

```json
{
    "niches": ["candles"],
    "platforms": ["shopify", "woocommerce"],
    "countries": ["US"],
    "minProducts": 10,
    "maxStores": 50,
    "enrichContacts": true,
    "includeApps": true
}
```

All fields: `niches[]`, `platforms[]`, `countries[]`, `maxStores`, `minProducts`, `enrichContacts`, `includeApps`, `domains[]`, `maxSearchPages`, `language`, `maxConcurrency`, `proxyConfiguration`.

### Output

One row per store:

```json
{
    "storeName": "Brooklyn Candle Studio",
    "domain": "brooklyncandlestudio.com",
    "url": "https://brooklyncandlestudio.com/",
    "platform": "shopify",
    "platformLabel": "Shopify",
    "platformConfidence": 100,
    "platformEvidence": ["Shopify script: https://cdn.shopify.com/…", "/meta.json: brooklyn-candle-studio.myshopify.com", "/products.json: 12 products on page 1", "sitemap: 196 products in 1/1 product sitemaps"],
    "niche": "candles",
    "productCount": 196,
    "productCountBand": "50-199",
    "currency": "USD",
    "country": "US",
    "apps": ["Judge.me", "Klaviyo", "Rebuy"],
    "paymentProviders": ["Apple Pay", "Google Pay", "PayPal", "Shop Pay"],
    "marketingTech": ["Google Analytics 4", "Meta Pixel", "TikTok Pixel"],
    "vendors": ["Brooklyn Candle Studio"],
    "productCategories": ["Candles", "Reed Diffusers"],
    "sampleProducts": [{ "title": "Fern + Moss Escapist Candle", "url": "https://brooklyncandlestudio.com/products/fern-moss-escapist-candle", "price": "38.00", "currency": "USD", "vendor": "Brooklyn Candle Studio" }],
    "emails": ["hello@brooklyncandlestudio.com"],
    "primaryEmail": "hello@brooklyncandlestudio.com",
    "phones": [],
    "socials": { "facebook": "https://www.facebook.com/brooklyncandlestudio", "instagram": "https://www.instagram.com/brooklyncandlestudio", "linkedin": null, "twitter": null, "youtube": null, "tiktok": "https://www.tiktok.com/@brooklyncandlestudio", "pinterest": null, "whatsapp": null },
    "instagramFollowers": null,
    "contactStatus": "ok",
    "myshopifyDomain": "brooklyn-candle-studio.myshopify.com",
    "evidence": "Shopify (100) — Shopify script: https://cdn.shopify.com/…; /meta.json: brooklyn-candle-studio.myshopify.com; /products.json: 12 products on page 1",
    "sources": ["google:site:myshopify.com candles", "https://brooklyncandlestudio.com/"],
    "scrapedAt": "2026-09-26T12:00:00.000Z"
}
```

The key-value store holds `STORES.csv` (spreadsheet copy) and `OUTPUT` (run summary: stores per platform and niche, candidates checked, drop reasons, search pages billed, engines used, transport statistics).

### Tips

- Niches work best as **product words a shopper would use** (`beeswax candles`, `dog treats`, `yoga leggings`), not industry labels.
- **Countries** restrict Google to pages from that country and skip stores whose country is known and different; stores whose country cannot be established are kept.
- **Minimum product count** only applies where the count is known (Shopify, WooCommerce). With a minimum set, stores whose count cannot be established are skipped too.
- Google's search proxy answers many queries with an unreadable JavaScript page; the Actor retries once, then falls back to Bing / DuckDuckGo, so a run may show `bing` or `ddg` in `sources`.

### FAQ

#### Does it need my Shopify or Google account?

No. It reads the public storefront (the same JSON your browser loads) and public search result pages.

#### Why is `productCount` empty for some stores?

BigCommerce, Magento, Wix and Squarespace do not publish a catalogue count without a key, so the field is `null` rather than a guess. Shopify and WooCommerce stores always carry an exact count (or `5000+` when a catalogue is larger than the five product sitemaps read).

#### Why do I get stores that are not exactly in my niche?

Search engines rank pages, not shops: a pharmacy that sells candles can surface for `candles`. The `niche` field tells you which search found it; `productCategories` and `sampleProducts` show what the store actually sells.

#### Can it scrape all products of a store?

No — this Actor finds and profiles stores. Use a product scraper on the `url` it gives you.

#### Is this legal?

It reads publicly available storefront pages and endpoints at a low rate and stores business (not personal) contact details published by the stores themselves. You are responsible for using the data in line with local law.

### Support

Open an issue on the Actor page or email the author.

# Actor input Schema

## `niches` (type: `array`):

One niche per line, the way a shopper would describe the products — e.g. `candles`, `yoga apparel`, `pet supplements`, `Bio Hundefutter`. Each niche is searched per platform; stores are found through Google and then verified on their own site.

## `platforms` (type: `array`):

Which storefront platforms to look for. Shopify and WooCommerce stores get exact product counts and currency from their public catalogue endpoints; BigCommerce, Magento, Wix and Squarespace are fingerprinted from the storefront HTML.

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

Optional. Two-letter country codes, e.g. `US`, `GB`, `DE`. Each search is run per country (Google's country restriction) and stores whose country is known and different are skipped. Stores whose country cannot be established are kept.

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

Stop after this many verified stores have been delivered (across all niches and platforms). Only delivered stores are charged.

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

Skip stores with fewer published products. Applies where the count is known (Shopify, WooCommerce); with a minimum set, stores whose count cannot be established are skipped too.

## `enrichContacts` (type: `boolean`):

Reads the homepage plus contact / about pages and pulls out email addresses, phone numbers and Facebook / Instagram / LinkedIn / X / YouTube / TikTok / Pinterest / WhatsApp links. Charged only when something was found.

## `includeApps` (type: `boolean`):

Fingerprints the storefront for apps (Klaviyo, Yotpo, Judge.me, Gorgias, Recharge, …), payment providers (Shop Pay, PayPal, Klarna, Afterpay, …) and marketing pixels (GA4, Meta, TikTok, …).

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

Paste store domains or URLs to verify and enrich without searching — e.g. `allbirds.com`. Verified stores are delivered as rows; sites that are not a store are skipped and not charged.

## `maxSearchPages` (type: `integer`):

Google result pages (10 results each) to read per niche × platform query. Each page is one paid SERP proxy request; searching stops early once enough candidates are queued.

## `language` (type: `string`):

Google interface language for the searches (`hl`), e.g. `en`, `de`, `fr`.

## `maxConcurrency` (type: `integer`):

How many stores are verified in parallel.

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

Storefronts are read through the run's own connection first (some Cloudflare rules reject proxy ranges but not the platform); this proxy is used only for hosts that block that path. Google searches always go through the Apify Google SERP proxy.

## Actor input object example

```json
{
  "niches": [
    "candles"
  ],
  "platforms": [
    "shopify",
    "woocommerce"
  ],
  "maxStores": 20,
  "minProducts": 0,
  "enrichContacts": true,
  "includeApps": true,
  "maxSearchPages": 2,
  "language": "en",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per verified store: domain, platform with evidence, product count, currency, country, apps, payment providers, pixels, sample products and contacts.

## `csv` (type: `string`):

Spreadsheet / CRM-ready CSV of the stores (first 5,000 rows).

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

Counts: stores delivered per platform and niche, candidates checked, drop reasons, search pages billed, transport stats.

# 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 = {
    "niches": [
        "candles"
    ],
    "platforms": [
        "shopify",
        "woocommerce"
    ],
    "maxStores": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("inovaflow/ecommerce-store-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 = {
    "niches": ["candles"],
    "platforms": [
        "shopify",
        "woocommerce",
    ],
    "maxStores": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("inovaflow/ecommerce-store-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 '{
  "niches": [
    "candles"
  ],
  "platforms": [
    "shopify",
    "woocommerce"
  ],
  "maxStores": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call inovaflow/ecommerce-store-finder --silent --output-dataset

```

## MCP server setup

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