# Shopify & WooCommerce E-commerce Store Leads (`weio/ecommerce-store-leads-by-platform`) Actor

Find Shopify, WooCommerce, BigCommerce, Wix and Squarespace stores by country, city and category, or check your own list, and get each store’s public business emails, phones and socials. Respects robots.txt. Pay per qualified lead plus Apify's tiny start fee; other rows are free.

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

## Pricing

from $5.00 / 1,000 qualified store leads

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 & WooCommerce Store Leads by Location

Find **Shopify, WooCommerce, BigCommerce, Wix and Squarespace stores** by country, state, city and category,
and get the business email, phone number and social links each store publishes on its own website.
Or paste your own list of domains and use it as an **ecommerce platform detector** with contact extraction.

You pay only for **qualified store leads**: a live store on a platform you asked for, with at least one public
business contact. Dead sites, non-stores, robots-blocked sites and stores without contacts are free.

Typical buyers: Shopify and WooCommerce app developers, ecommerce agencies, wholesalers and B2B suppliers
selling to independent retailers, and payments, shipping or marketing SaaS teams building an ecommerce
lead list.

### What you get

One row per qualified store:

| Field | What it is |
| --- | --- |
| `domain` | the store's website |
| `platform` | `shopify`, `woocommerce`, `bigcommerce`, `wix` or `squarespace` |
| `business_name` | from the site (`og:site_name`, else the page title) |
| `emails` | role/business addresses only (info@, sales@, support@, orders@ ...). Personal-name addresses are dropped on purpose |
| `phones` | from `tel:` links and visible text (North American format detection; check before dialling) |
| `socials` | first Facebook, Instagram, LinkedIn, X, YouTube and TikTok profile linked from the site |
| `contact_page_url` | the contact page, when one was found and robots.txt allowed it |
| `category`, `city`, `region`, `country` | what the store sells and where it is (discovery mode) |
| `online_store` | `true` when products are offered for sale on the homepage or the shop page it links to |
| `final_url`, `pages_checked`, `checked_at` | where the details were read, and when |
| `data_licences`, `source` | provenance of the discovery record (see Data sources) |

### Two ways to use it

#### 1. Find stores (discovery mode)

Leave **Your own store URLs** empty and choose filters. Example: Shopify and WooCommerce clothing stores in
Texas.

```json
{
  "platforms": ["shopify", "woocommerce"],
  "countries": ["US"],
  "regions": ["TX"],
  "categories": ["clothing_store"],
  "maxLeads": 200
}
```

More examples:

- WooCommerce and Shopify furniture stores in the UK: `{"platforms": ["woocommerce", "shopify"], "countries": ["GB"], "categories": ["furniture_store"]}`
- Any platform, bike shops in Australia: `{"countries": ["AU"], "categories": ["bike_store"]}`
- Coffee sellers in Seattle and Portland: `{"countries": ["US"], "cities": ["Seattle", "Portland"], "domainKeywords": ["coffee"]}`

The actor picks matching retail businesses from its built-in index (about 2.4 million retail websites in 170
countries, including roughly 590,000 in the US, 198,000 in the UK and Germany each, 78,000 in Canada and 67,000
in Australia), visits each store's own website live, and keeps only the stores that qualify. It stops at
**Maximum leads**, so a run never costs more than `maxLeads x $0.005`.

Run it again with the stores you already have in **Skip these stores** (`excludeDomains`) to get new ones
without paying twice.

Typical results (test runs on 2026-10-03, all platforms and all retail categories): 100 qualified US leads from
886 sites checked in about 7 minutes; 100 UK, Australian and Canadian leads from 540 sites in about 5 minutes.
About two thirds of those leads were Shopify stores. Narrow categories such as clothing, jewelry or gifts
qualify more often than hardware or building supply. Most sites that are checked but not charged are not on one
of the five platforms, are dead domains, or block automated requests.

Filters:

- `platforms`: any of shopify, woocommerce, bigcommerce, wix, squarespace (default: all five).
- `countries`: two-letter codes (US, GB, CA, AU, DE ...).
- `regions`: state or province codes as used in postal addresses (TX, CA, NY, ON, BC, NSW, VIC ...). Outside
  the US, Canada and Australia, regions follow the source data and are less consistent.
- `cities`: city names; case and accents are ignored.
- `categories`: what the store sells, for example clothing\_store, jewelry\_store, furniture\_store,
  flowers\_and\_gifts\_store, bike\_store, pet\_store, bookstore, cosmetics\_and\_fragrance\_store,
  sporting\_goods\_store, liquor\_store, eyewear\_store or fashion\_and\_apparel\_store (a parent that includes all
  apparel sub-categories). The input form lists every available category.
- `domainKeywords`: keep stores whose web address contains a word (vintage, organic, surf ...).

#### 2. Check your own list (list mode)

Put up to 5,000 domains or URLs in **Your own store URLs**. You get one row per site with the detected
platform, so you can see which of your prospects run Shopify, WooCommerce, BigCommerce, Wix or Squarespace.
Only qualified stores are charged; every other row is free and says why (`not a supported store platform`,
`robots disallow`, `http 403`, `no public business contact found` ...). The same store written several ways
(`shop.com`, `https://www.shop.com/`) is checked and charged once. With **Only stores with a business email**,
sites without one are left out of the results. **Countries** is a required field (it stops a blank run from
starting an unscoped search); list mode ignores it, so any value works, as in this API input:

```json
{ "countries": ["US"], "websites": ["kieljamespatrick.com", "https://example-shop.com"], "platforms": ["shopify", "woocommerce"] }
```

#### Workflow example: build a retailer prospect segment

A payments, shipping or ecommerce app team can start with a narrow segment rather than buy a large database:
select `shopify` and `woocommerce` in **Store platforms**, choose the **Countries** or **States / regions** where
it sells, and optionally add a **Store categories** value. Set **Maximum leads** to the number its sales team can
review. The finished dataset contains the store `domain`, detected `platform`, public business contact details
and the `category`, `city`, `region` and `country` fields, so the buyer can filter it in its own CRM or
spreadsheet before any outreach. Run the same filters later with the prior domains in **Skip these stores** to
request only newly discovered stores. Weio does not send messages or log in to stores, and contact details are
public site details, not verified deliverability data.

### Output example

A real row from a test run on 2026-10-02 (public business details as published on the store's own site):

```json
{
  "domain": "kieljamespatrick.com",
  "platform": "shopify",
  "business_name": "Kiel James Patrick",
  "emails": ["customerservice@kieljamespatrick.com", "info@kieljamespatrick.com", "media@kieljamespatrick.com"],
  "phones": ["+14016194647", "+18886438663"],
  "socials": {},
  "contact_page_url": "https://kieljamespatrick.com/pages/contact-us",
  "category": "clothing_store",
  "city": "Newport",
  "region": "RI",
  "country": "US",
  "data_licences": ["CDLA-Permissive-2.0"],
  "online_store": true,
  "final_url": "https://kieljamespatrick.com/",
  "robots_allowed": true,
  "pages_checked": ["https://kieljamespatrick.com/", "https://kieljamespatrick.com/pages/contact-us"],
  "source": "overture-maps-places",
  "error": null,
  "checked_at": "2026-10-03T04:05:11+00:00"
}
```

A run summary (candidates checked, leads found, platforms seen and why other sites were not charged) is saved
in the run's key-value store as `SUMMARY`.

### Pricing

**$5.00 per 1,000 qualified store leads** ($0.005 per lead), the same on every Apify plan. You do not pay for
the compute the actor uses; the only other charge is Apify's standard start fee of $0.00005 per run (per GB of
run memory; the default is 1 GB).

A lead is charged only when all of these are true:

1. the site runs one of the platforms you selected,
2. it offers products for sale (Shopify and BigCommerce sites always count; WooCommerce and Wix sites need
   products on the homepage or on the shop page it links to, and Squarespace sites a live store, unless you
   turn **Require an online store** off; a store plugin with an empty shop does not count),
3. robots.txt allowed every page that was read, and
4. the site publishes at least one business email, phone or social profile (or an email, with
   **Only stores with a business email**).

Set **Maximum leads** (discovery) or Apify's maximum cost per run to cap spend. If a run is restarted by the
platform, it resumes where it stopped and never charges a store twice. For comparison as of
2026-10-02, StoreLeads, BuiltWith and Wappalyzer lead lists are sold as monthly subscriptions from $75, $295
and $250 a month.

### How it works, and how it respects websites

- Store discovery uses an open, dated dataset (Overture Maps Places), not search-engine scraping, not the
  Shop app, and no logins.
- For each site the actor first reads `robots.txt` (RFC 9309, user agent `WeioBot`). If the homepage is
  disallowed, nothing else is fetched. Every redirect and every optional page (one contact page, one about
  page) is checked against robots.txt before it is read. If robots.txt cannot be read because of a server error
  or rate limit, the site is skipped.
- At most four pages per site are read: the homepage, one shop page (only when needed to confirm products are
  for sale), a contact page and an about page. No forms, no logins,
  no customer data, no page text is stored or returned.
- The platform is identified from assets the platform itself serves (for example `cdn.shopify.com`, WooCommerce
  plugin files, BigCommerce Stencil), never from a page merely mentioning a platform's name.

### Limitations

- Some sites refuse automated requests (HTTP 403 or 429). The actor identifies itself honestly, waits as long
  as a site asks before one retry, never tries to get around a refusal, and does not charge for refused sites.

- The index comes from a database of physical places, so it favours stores with a shop, studio or showroom.
  Online-only brands without a listed location are under-represented.

- The index is a monthly snapshot (Overture release 2026-09-23). Every store is checked live at run time, so
  closed sites and dead domains are skipped and never charged, but they do not count toward your leads either.

- Sites that load their products or contact details only with JavaScript, or that block automated requests,
  are not recognised as stores or return few details, and are not charged. In an independent check of 24
  charged leads, this rule removed the only invalid ones (store plugins with empty shops) at the cost of
  missing about 1 in 10 real stores whose products load with JavaScript.

- Phone detection targets North American formats; international numbers are found when they appear in
  `tel:` links.

### Data and responsibility

- Only public pages are read and only role email addresses (info@, sales@ ...) are returned.
- You are responsible for using the results lawfully, including email-marketing and data-protection rules such
  as CAN-SPAM (real sender, postal address, working opt-out), GDPR and CASL.
- A business that wants its site left out can email sales@weio.ai and we will add it to a skip list; skipped
  sites are never checked, returned or charged.

### Data sources and licences

The discovery index is derived from **Overture Maps Places**, release 2026-09-23.0, accessed 2026-10-02
(Overture Maps Foundation, overturemaps.org). Weio kept only the website hostname, the Overture category and
the country, region and locality (place names only) of each retail place listing a website, dropped closed,
low-confidence and chain records and most records whose website is not the business's own (social networks,
marketplaces, link pages), and kept only records whose every source licence is CDLA-Permissive-2.0,
Apache-2.0 or CC0-1.0. Contact details are not from Overture; they are read live from each store's website.
Each row's `data_licences` lists the licences of the record it came from.

Overture Places source attribution:

- Data from Meta, Microsoft, PinMeTo, Krick, RenderSEO, DAC and BrightQuery. Available under
  [CDLA Permissive 2.0](https://cdla.dev/permissive-2-0/).
- Data from Foursquare. Copyright 2024 Foursquare Labs, Inc. All rights reserved. Available under
  [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0). Foursquare data was transformed to the Overture
  schema. Changed: 2026-03-18. [NOTICE.txt](https://opensource.foursquare.com/places-notice-txt/). Further
  changed by Weio on 2026-10-02 as described above.
- Data from AllThePlaces. Available under [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/).

Foursquare OS Places notice, reproduced in full:

> © 2026 Foursquare Labs, Inc. All rights reserved. The Foursquare OS Places dataset (the "Data") is licensed
> under the Apache License, Version 2.0 (the "License"). You may not use, modify, or distribute the Data except
> in compliance with the License. As set forth more fully in the License, if you use, modify, or distribute the
> Data, you must: provide recipients with a copy of the License; if applicable, include prominent notices to the
> extent you've changed the Data; preserve attribution to Foursquare, including preserving the full content of
> this NOTICE.txt file. To ensure appropriate attribution to Foursquare, we recommend the following: if
> using/distributing the Data in flat file form as-is or after making changes/modifications: include this
> NOTICE.txt file, which may be modified to include an additional notice of your changes/modifications, if any;
> if using/distributing the Data in API form as-is or after making changes/modifications: include a copy of the
> content from this NOTICE.txt file prominently in your developer documentation for such API, which may be
> modified to include an additional notice of your changes/modifications, if any. You may obtain a copy of the
> License at http://www.apache.org/licenses/LICENSE-2.0. Unless required by applicable law or agreed to in
> writing, the Data distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
> CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing
> permissions and limitations under the License.

The full licence texts ship with the actor (`LICENSES/`, `NOTICE.txt`). Weio is not affiliated with or
endorsed by Overture Maps Foundation, Foursquare or the other data providers, or by Shopify, WooCommerce,
BigCommerce, Wix or Squarespace.

### Related actors from Weio

- [Website Tech Stack Detector](https://apify.com/weio/website-tech-stack-detector): CMS, store platform, analytics, pixels and hosting of a list of websites.
- [Website Contact Details Extractor](https://apify.com/weio/website-contact-details-extractor): business emails, phones and social links from any list of websites.
- [Domain WHOIS, DNS and Email Security Checker](https://apify.com/weio/domain-whois-dns-email-security-checker): registration, DNS, MX, SPF and DMARC for a list of domains.

Built and maintained by Weio, Inc. The actor was written and is operated by AI agents (Anthropic Claude), with a
person accountable at Weio. Questions and opt-outs: sales@weio.ai.

# Actor input Schema

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

Only stores on these platforms are returned and charged. Leave empty for all five.

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

Required to prevent an unscoped paid discovery run. Choose a country for discovery; list mode ignores it.

## `regions` (type: `array`):

Optional. State, province or region codes as in postal addresses, for example CA, TX, NY, ON, NSW.

## `cities` (type: `array`):

Optional. City names, for example Austin or San Diego (case and accents ignored).

## `categories` (type: `array`):

What the store sells (Overture Maps categories; a parent such as 'Fashion and apparel store' includes all its sub-categories). Empty means all retail.

## `domainKeywords` (type: `array`):

Optional. Keep only stores whose website address contains one of these words, for example coffee, vintage, bike.

## `maxLeads` (type: `integer`):

Stop after this many qualified leads (each one is charged). Discovery mode only.

## `excludeDomains` (type: `array`):

Optional. Domains you already have, so a repeat run does not return (or charge) them again.

## `websites` (type: `array`):

Optional. If you list domains or URLs here (up to 5,000), the actor checks exactly these instead of finding stores, and returns one row per site. Non-stores, robots-blocked and contact-less sites are free rows.

## `requireOnlineStore` (type: `boolean`):

WooCommerce, Wix and Squarespace sites count only when products are offered for sale (an installed shop with no products does not count). Turn off to include any business site built on these platforms.

## `onlyWithEmail` (type: `boolean`):

Skip (and do not charge for) stores where no business email such as info@ or sales@ was found.

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

How many websites are checked at the same time (1-32).

## Actor input object example

```json
{
  "countries": [
    "US"
  ],
  "categories": [
    "clothing_store"
  ],
  "maxLeads": 10,
  "requireOnlineStore": true,
  "onlyWithEmail": false,
  "concurrency": 16
}
```

# Actor output Schema

## `storeLeads` (type: `string`):

The default dataset, overview view.

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

Candidates checked, leads found, platforms seen and why other sites were not charged.

# 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 = {
    "countries": [
        "US"
    ],
    "categories": [
        "clothing_store"
    ],
    "maxLeads": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("weio/ecommerce-store-leads-by-platform").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 = {
    "countries": ["US"],
    "categories": ["clothing_store"],
    "maxLeads": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("weio/ecommerce-store-leads-by-platform").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 '{
  "countries": [
    "US"
  ],
  "categories": [
    "clothing_store"
  ],
  "maxLeads": 10
}' |
apify call weio/ecommerce-store-leads-by-platform --silent --output-dataset

```

## MCP server setup

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

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/YI4HH2DoaS71IHhbh/builds/KHiDpkeaeKb6rW6NN/openapi.json