# Store Qualifier for Shopify Stores: Country, Catalogue & Prices (`wisekit/store-qualifier`) Actor

Give it store domains. For each one: is it on Shopify, home country and currency, product count, min, max and median price in its own currency, sample products, and own label vs reseller. Reads only the store's public catalogue data, nothing else. Unreadable stores are free.

- **URL**: https://apify.com/wisekit/store-qualifier.md
- **Developed by:** [Wisekit](https://apify.com/wisekit) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Store Qualifier for Shopify Stores: Country, Catalogue & Prices

Turn a list of store domains into a ranked shortlist: which are on Shopify, where they sell, how big the catalogue is and what they charge.

Give it a list of online store domains. For each store you get one row: is it built on Shopify, its home country and currency, how many products it sells, its price range and median price in its own currency, and whether it mostly sells its own label or other brands. Optional, off by default: the generic business address a store publishes on its own site (info@, support@ ...), up to 3 per store, for a partnership, wholesale or support enquiry. One charge per store whose product catalogue was read ($0.004); stores that aren't on Shopify, or whose catalogue can't be read, are free. If a store redirects to its main domain, that domain is read instead.

Try the **Free demo** first: five fictional stores, no store is read and nothing is charged.

> **Use the results lawfully.** This Actor reads only each store's public storefront data and returns facts about the store and its catalogue, plus, only if you turn it on, the generic business email addresses the store publishes on its own site. Some vendor and store names are names of people (a maker or owner trading under their own name), so treat them with the same care as any personal information. Check that your use of the results meets the laws and terms that apply to you. This Actor is not legal advice. Not affiliated with or endorsed by Shopify Inc.

![Stores view from a free demo run: three fictional stores qualified with country, currency, product count, prices and own-label signal; two reported free](https://api.apify.com/v2/key-value-stores/kPGO4UMT3mdrVrLfq/records/qualifier-demo?signature=1KSOlZnGLZtYNhMt9Nuoc)

*Sample output from demo mode (fictional stores, labelled DEMO DATA).*

### Who uses it

- **Agencies and freelancers** sizing a list of prospective client stores before a pitch: platform, market, catalogue size and price band in one table.
- **App and SaaS sellers** filtering a domain list down to Shopify stores in the countries they serve.
- **Suppliers and wholesalers** looking for stores that resell other brands (`ownLabelSignal: reseller`) rather than make their own.
- **Investors and analysts** checking catalogue size, price band and recent activity (`newestProductPublishedAt`) across a set of stores.
- **AI agents and automations** that need a yes/no "is this a Shopify store, and how big?" answer from one line of JSON.

### What data do you get per store?

| Field | What it is |
|---|---|
| `status`, `summary` | `ok` (qualified: catalogue read) or why the store was not qualified, and a one-line summary |
| `isShopify` | `true` when the store runs on Shopify |
| `storeName` | The name the store gives itself in its storefront data |
| `homeCountry`, `homeCurrency` | The store's home country and currency, as the store states them |
| `productCount`, `productCountIsMinimum` | Products in the public catalogue (counted up to 1,000; `true` means "at least") |
| `minPrice`, `maxPrice`, `medianPrice`, `currency` | Price range and median product price, in the store's home currency |
| `sampleProductTitles`, `topProductTypes` | Up to 5 product titles and the 3 most common product types |
| `ownLabelShare`, `ownLabelSignal`, `topVendors`, `vendorCount` | Share of products whose vendor is the store itself: `own_label` (70% or more), `mixed`, `reseller` (30% or less), or `single_other_vendor` (one vendor name that differs from the store name, often the company's legal name or the owner's name). `topVendors` and `vendorCount`: vendor names the store lists in its public product feed (usually brands; on some stores a maker's or owner's own name) |
| `newestProductPublishedAt` | When the newest product in the catalogue was published: a sign of an active store |
| `publicEmails`, `emailSource` | Only with `includePublicEmails` on: up to 3 role-based business addresses (info@, hello@, support@ ...) on the store's own domain, and the page each was found on (same order). Empty otherwise |
| `demo` | `true` only on free demo rows (absent on real runs) |

Export the dataset as JSON, CSV or Excel, or send it to Google Sheets through Apify's integrations.

### How to qualify a list of stores

1. Paste your store domains in **Store domains or URLs**, one per line. Bare domains (`example-store.com`) and full URLs both work; only the domain is used.
2. Click **Start**. Five stores are read at a time; each takes about 4 seconds (usually 2 to 5 seconds more with public business emails on).
3. Open the **Stores** table in the Output tab, sort by `productCount` or `medianPrice`, and filter on `status` = `ok`.

#### Input

| Field | Default | Notes |
|---|---|---|
| `storeUrls` | (required) | Domains or URLs, one per line. Up to 500 per run (3 on the Apify free plan). |
| `maxProductsPerStore` | `1000` | 1 to 1,000. |
| `includePublicEmails` | `false` | Also return public business emails (role-based, store's own domain, up to 3), +$0.002 per store with at least one. See "Public business emails". |
| `demoMode` | `false` | Free demo: five fictional stores from bundled data, no store is read, nothing is charged, other fields are ignored. |

Example input: `{"storeUrls": ["example-store.com", "https://www.another-store.com"]}`

Free demo input: `{"storeUrls": ["demo"], "demoMode": true}`

#### Example row (fictional store)

```json
{
  "store": "example-store.com",
  "status": "ok",
  "summary": "Shopify store (AU, AUD); 240 products; prices AUD 12–189, median 45; mostly own label (92% own).",
  "isShopify": true,
  "storeName": "Example Store",
  "homeCountry": "AU",
  "homeCurrency": "AUD",
  "currency": "AUD",
  "productCount": 240,
  "productCountIsMinimum": false,
  "minPrice": 12,
  "maxPrice": 189,
  "medianPrice": 45,
  "sampleProductTitles": ["Linen Shirt", "Canvas Tote", "Wool Beanie", "Cotton Tee", "Denim Jacket"],
  "ownLabelShare": 0.92,
  "ownLabelSignal": "own_label",
  "vendorCount": 2,
  "topVendors": [{ "vendor": "Example Store", "count": 221 }, { "vendor": "Other Brand", "count": 19 }],
  "topProductTypes": [{ "productType": "Shirts", "count": 80 }],
  "newestProductPublishedAt": "2026-11-02T00:00:00Z"
}
```

### How much does it cost to qualify a store?

**$0.004 per store qualified** (pay per event `store-qualified`, $4 per 1,000 qualified stores), charged only when the store's product catalogue was read (an empty catalogue that was read counts). With `includePublicEmails` on, **$0.002 per qualified store where at least one public business email is returned** (event `contact-found`); stores with none are not charged extra. Nothing else is charged. Shopify stores whose product feed can't be read (`feed_unavailable`: you still get the name, country and currency), stores that are not on Shopify, blocked, password protected, disallowed by robots.txt, rate limited, unreachable or excluded at their owner's request are free. Your maximum charge per run is respected, counting stores still being read. The free demo is free.

- **Example:** 100 domains, 60 on Shopify and readable: 60 × $0.004 = **$0.24**. The other 40 cost nothing.
- **With public emails:** the same 60 stores, 35 of them with a public business email: $0.24 + 35 × $0.002 = **$0.31**.
- **Apify's free plan:** up to 3 stores per run, so you can try it on real stores before you pay for anything.
- **Speed:** about 4 requests and 4 seconds per store (3 test stores, 17 Nov 2026), 5 stores at a time; usually 2 to 5 seconds more per store with public business emails on, up to about 20 seconds on a slow store (5 stores, measured locally 18 Nov 2026).

### Public business emails

Off by default. Turn on `includePublicEmails` and, for each qualified store, the Actor reads at most 4 pages on the store's own website: the homepage, its contact page (`/pages/contact` or the contact page linked from the homepage) and the Shopify policy pages `/policies/contact-information`, `/policies/refund-policy` and `/policies/privacy-policy`. Each page is read only if the store's robots.txt allows it, at least 1 second apart, with the same honest User-Agent. It stops as soon as the contact page gives an address, or after 3 addresses.

- **Only generic addresses the store publishes itself:** the part before the @ must be a role such as info, hello, contact, support, help, care, customerservice, sales, shop, team, enquiries, wholesale, press or partnerships (an optional region suffix such as support-au is allowed). Transactional mailboxes (orders, returns, shipping, accounts, billing, admin) are not returned.
- **Dropped:** anything that could be a person's address (first names, initials, firstname.lastname), addresses on any other domain, and free mail addresses (gmail.com, outlook.com and the like), even when the store shows them. Only addresses in plain page text or `mailto:` links are read; addresses a store has disguised or hidden from automated readers ("\[at]" spellings, character codes, email-protection services) are skipped.
- **Stores that say no:** if the homepage or a contact page asks not to receive unsolicited messages (for example "no solicitations"), none of that store's addresses are returned and `contact-found` is not charged.
- **No names, phone numbers or street addresses** are returned.
- **Your responsibility:** use the addresses lawfully, and only for relevant, individual business enquiries. Publishing an address is not consent to every message. Laws differ by country. Australia's Spam Act 2003 requires consent for commercial email (consent can be inferred from a published address only in limited cases, for messages relevant to the recipient's business role), and it also restricts acquiring or using automatically collected address lists to send unsolicited commercial email. In the EU and UK, GDPR and ePrivacy/PECR rules apply, and a generic address of a sole trader or of a business named after its owner can still be personal data. In the US, CAN-SPAM sets rules for commercial email, including a working opt-out. Don't send unsolicited commercial email where the law forbids it. This is not legal advice.
- **Store owners** can ask for their addresses not to be collected: open an issue on the Issues tab with your domain. It is added to an exclusion list; the store can still be qualified, but its pages are never read for emails.

### What it never does

- No names of people, no phone numbers or street addresses. Email addresses only with `includePublicEmails` on, and only role-based addresses on the store's own domain (see above).
- No pages beyond a fixed small set on the store's own site: robots.txt, the store's public `meta.json` and its public product feed, plus the 4 email pages above when you turn that option on. A redirect is only followed to one of those. If a store redirects to its main domain, that domain is read instead; no other links are followed.
- No login, cookies, proxies or browser. robots.txt is read first and obeyed; at least 1 second between requests, or the store's Crawl-delay; a store that refuses us, shows a bot check or is password protected is left alone at once.
- Your results stay in your own Apify dataset. We keep no copy, and the run log shows counts and statuses only.

### Is it legal to check stores this way?

The Actor reads only data each store publishes for every visitor: its robots.txt, its public store information (`meta.json`) and its public product feed, and, only if you turn on public business emails, up to 4 of its own public pages (homepage, contact and policy pages). It obeys robots.txt, identifies itself honestly, waits between requests and stops at once when a store refuses.

It returns facts about stores and their catalogues, and, only if you turn it on, generic business email addresses that a store publishes on its own site. It never returns names or phone numbers. Some vendor names can be a person's name (see above).

Don't use the results to build mailing lists, or to send unsolicited commercial email or messages where the law forbids it; anti-spam laws such as CAN-SPAM, GDPR and ePrivacy rules, and Australia's Spam Act 2003 may apply.

Whether your own use of the results is lawful depends on what you do with them and where you are, so check the laws and terms that apply to you. This is not legal advice.

### Use it from the API or an AI agent

Only `storeUrls` is required. Python (`pip install "apify-client>=3"`):

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("wisekit/store-qualifier").call(run_input={
    "storeUrls": ["example-store.com", "another-store.com"],
})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["store"], row["status"], row.get("summary"))
```

curl, in one request (waits for the run and returns the rows; add `?maxTotalChargeUsd=1.00` to cap the cost):

```bash
curl -s -X POST \
  "https://api.apify.com/v2/acts/wisekit~store-qualifier/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"storeUrls":["example-store.com","another-store.com"]}'
```

**AI agents (MCP):** add Apify's MCP server to Claude Desktop, Claude Code, Cursor or another MCP client with this Actor as a tool:

```json
{
  "mcpServers": {
    "apify-store-qualifier": {
      "url": "https://mcp.apify.com?tools=wisekit/store-qualifier",
      "headers": { "Authorization": "Bearer <APIFY_TOKEN>" }
    }
  }
}
```

Prompts to try: "Run the store qualifier in demo mode and summarise the table." (free) or "Qualify these store domains and tell me which are on Shopify, their home country and median price: example-store.com, another-store.com." The run's status message gives the result in one line, for example "Qualified 3/5 stores (3 on Shopify)."

### Qualify new stores every week (schedule recipe)

1. In Apify Console, click **Save as a new task** with your input (for example the domains your team added this week).
2. Add a **Schedule** to the task, for example every Monday at 07:00.
3. Under the task's **Integrations**, add Slack, Google Sheets or a webhook on "Run succeeded" to send the Stores table where your team works.

### Status values

`ok`, `not_shopify`, `feed_unavailable`, `blocked`, `password_protected`, `robots_disallowed`, `robots_unavailable`, `skipped_crawl_delay`, `rate_limited`, `time_limit`, `duplicate_store`, `error`, `excluded_by_request`, `invalid_input`, `skipped_max_charge`, `skipped_plan_limit`, `skipped_run_limit`. Only `ok` is charged.

### Store owners

If you run a store and don't want it read by this Actor, open an issue on this Actor's Issues tab with your domain. It is added to an exclusion list and gets no further requests. If you only want your email addresses left out, say so: the store goes on a separate list and its pages are never read for emails.

### Other Wisekit Actors

- [Price & Stock Monitor for Shopify Stores](https://apify.com/wisekit/product-price-monitor): monitor the stores that qualify. Every product with prices and stock, and what changed since your last run.
- [AI Brand Visibility Tracker](https://apify.com/wisekit/ai-search-visibility-tracker): see whether ChatGPT, Perplexity, Gemini and Claude recommend a brand or its competitors.

### Feedback and support

Found a bug, or want a field added? Open an issue on the **Issues** tab; we aim to reply within 24 hours. Ratings and reviews, good or bad, help other people find the Actor and help us improve it.

### Changelog

- **18 Nov 2026:** optional public business emails (`includePublicEmails`, off by default): up to 3 role-based addresses on the store's own domain, plain text and mailto: links only, none when the store asks not to receive unsolicited messages, +$0.002 per store with at least one (`contact-found`); "Public business emails" view.
- **17 Nov 2026:** free demo mode (five fictional stores, no charge); form instructions; README with examples, API and agent snippets.
- **17 Nov 2026:** first public release: qualifier only, $0.004 per store qualified.

# Actor input Schema

## `demoMode` (type: `boolean`):

Tick to see sample output for free: five fictional stores from bundled data (three qualified, one not on Shopify, one password protected). No store is read and nothing is charged; other fields are ignored, though "storeUrls" still needs a value (any text works). Rows are labelled "demo": true. Agent example: {"storeUrls":\["demo"],"demoMode":true}.

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

Required. The online stores to qualify, one per line: a bare domain ("example-store.com") or any URL on the store (only the domain is used). Up to 500 stores per run (3 on the Apify free plan). Each store's robots.txt is read first and obeyed. Stores that are not on Shopify, block us, are password protected, disallow us in robots.txt or can't be read are reported and not charged. Agent example: {"storeUrls":\["example-store.com","https://www.another-store.com"]}.

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

The most products read from a Shopify store's product feed to count products and work out prices and the own-label signal (1 to 1,000, in pages of 250). When a store has more, productCountIsMinimum is true. Default 1,000.

## `includePublicEmails` (type: `boolean`):

Off by default. For each qualified store, also read up to 4 pages on the store's own website (homepage, contact page, and its contact-information, refund and privacy policy pages), each only if robots.txt allows it, and return up to 3 role-based business addresses such as info@, hello@, support@ or sales@ on the store's own domain, with the page each was found on. Addresses that could belong to a person (names, initials), addresses on other domains and free mail addresses (gmail.com and similar) are never returned; only plain addresses in page text or mailto: links are read (disguised or hidden addresses are skipped), and none when the store asks not to receive unsolicited messages; no names or phone numbers. Costs $0.002 per store where at least one address is returned (event contact-found), on top of the store price; stores with none are not charged extra. Use them lawfully, for relevant, individual business enquiries: anti-spam and privacy laws (Australia's Spam Act 2003, GDPR and ePrivacy/PECR in the EU and UK, CAN-SPAM in the US and others) restrict unsolicited commercial email and the use of collected address lists. Example: true.

## Actor input object example

```json
{
  "demoMode": false,
  "storeUrls": [
    "allbirds.com"
  ],
  "maxProductsPerStore": 1000,
  "includePublicEmails": false
}
```

# Actor output Schema

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

One row per store: status, one-line summary, Shopify or not, home country and currency, product count, price range and median, own-label signal and top vendors.

## `emails` (type: `string`):

With includePublicEmails on: role-based business addresses on the store's own domain and the page each was found on.

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

Counts only: stores qualified and on Shopify; status, requests and seconds per store.

# 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 = {
    "storeUrls": [
        "allbirds.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wisekit/store-qualifier").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 = { "storeUrls": ["allbirds.com"] }

# Run the Actor and wait for it to finish
run = client.actor("wisekit/store-qualifier").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 '{
  "storeUrls": [
    "allbirds.com"
  ]
}' |
apify call wisekit/store-qualifier --silent --output-dataset

```

## MCP server setup

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

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/bBuvaBP3lzoMLDwRW/builds/n2HOZOvW3Y6T7VHYW/openapi.json
