# Shopify Store Leads Scraper (`solidcode/shopify-store-leads-scraper`) Actor

\[💰 $5 / 1K leads] Find Shopify stores by product keyword or category and turn them into sales leads — store name, website, email, phone, address, and Facebook, Instagram & TikTok profiles. You only pay for stores that include an email.

- **URL**: https://apify.com/solidcode/shopify-store-leads-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Shopify Store Leads Scraper

Turn the Shopify marketplace into a contactable lead list — discover live Shopify stores by product keyword or category and export each one with its email, phone, full postal address, store rating, and social profiles. Built for B2B sales teams, marketing agencies, and DTC tool vendors who need verified merchant contacts for outreach without hand-prospecting Shopify stores one site at a time.

### Why This Scraper?

- **Pay for leads, not lookups** — you are charged the lead rate only for stores that come back with a verified email address. Stores with no email are billed at the bare result rate, so you never pay full price for a dead contact.
- **Verified email, phone, and full postal address per store** — street, city, postal code, and country parsed into clean fields, ready for a CRM import.
- **Up to 6 social profiles per store** — Facebook, Instagram, Pinterest, YouTube, Twitter, and TikTok handles captured wherever the merchant publishes them.
- **14 product categories, or search any keyword** — search "organic coffee" or "yoga mat", or browse whole verticals like Beauty, Home, Pet supplies, Fitness & nutrition, and Food & drinks.
- **myShopify domain plus live website URL for every store** — the canonical `*.myshopify.com` identifier and the public storefront link, so you can match against existing app installs or platform databases.
- **Store rating and review counts to qualify leads** — aggregate rating, total product ratings, and total product reviews on every row, so you can prioritize established merchants over brand-new shops.
- **2–3 sample products with live pricing and currency** — see exactly what each store sells and at what price point before you reach out.
- **12 store-location filters and a 49-country ships-to filter** — target US, UK, Canada, Australia, the Nordics, Europe, or all English-speaking countries, and narrow by where stores ship.
- **Up to 10,000 stores per run** — build a full territory's worth of merchant leads in a single invocation.

### Use Cases

**Lead Generation**
- Build outreach lists of contactable Shopify merchants with email and phone
- Qualify prospects by store rating and review volume before you reach out
- Export ready-to-import CRM rows with clean address and contact columns
- Segment leads by product category for targeted email campaigns

**Agency Prospecting**
- Find DTC brands selling in your niche that need design, ads, or SEO help
- Spot stores with thin review counts that are early in their growth curve
- Pull a city or country's worth of local Shopify sellers for regional pitches
- Identify merchants by category to match your agency's specialism

**Market Research**
- Map how many active stores sell a given product across a region
- Benchmark sample-product price points within a category
- Track which countries dominate a product vertical
- Size an addressable market of Shopify brands before a launch

**Competitive & Partnership Analysis**
- Discover competing brands selling the same keyword products
- Find integration or affiliate partners by category and store quality
- Compare social-presence breadth (which networks merchants actually use)
- Build a list of merchants ranked by rating for partnership outreach

### Getting Started

#### Search by Keyword

The simplest run — find stores selling a product and collect 50 leads:

```json
{
    "query": "organic coffee",
    "maxItems": 50
}
````

#### Browse a Category in One Country

Pull beauty stores based in the United States only:

```json
{
    "category": "beauty",
    "storeLocation": "US",
    "maxItems": 100
}
```

#### Filtered Lead List

Find mid-priced candle stores that have stock and ship to Germany:

```json
{
    "query": "scented candles",
    "priceMin": 20,
    "priceMax": 60,
    "inStock": true,
    "shipsTo": "DE",
    "maxItems": 200
}
```

#### Advanced — Full Targeting

Local sellers in the UK & Ireland, on-sale fitness products, sorted into a large lead pull:

```json
{
    "query": "yoga mat",
    "category": "fitness-nutrition",
    "storeLocation": "UK_IRELAND",
    "shipsFrom": true,
    "onSale": true,
    "priceMin": 15,
    "maxItems": 1000
}
```

### Input Reference

#### What to Find

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `query` | string | `"organic coffee"` | A product keyword to discover stores selling that item, such as 'organic coffee', 'yoga mat', or 'scented candles'. Leave empty to browse a whole category instead. |
| `category` | select | `All categories` | Limit results to stores selling products in this category. Leave empty to search across all categories. Choices: All categories, Women, Men, Accessories, Beauty, Home, Electronics, Luggage & bags, Toys & games, Pet supplies, Fitness & nutrition, Baby & toddler, Food & drinks, Sporting goods, Arts & crafts. |

#### How Many

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | `50` | Maximum number of stores to return. Each store is one lead. Higher numbers take longer and cost more. Up to 10,000. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `storeLocation` | select | `Worldwide` | Only return stores based in this country or region. Choose 'Worldwide' to include stores from everywhere. Options include United States, United Kingdom, Canada, Australia, New Zealand, Ireland, English-speaking countries, UK & Ireland, Europe, North America, Nordics, and Oceania. |
| `shipsTo` | select | `No filter` | Only return stores that ship to this country. Leave empty for no shipping filter. Covers 49 countries across the Americas, Europe, Asia-Pacific, and MENA. |
| `priceMin` | integer | null | Only return stores with sample products at or above this price. Leave empty for no minimum. |
| `priceMax` | integer | null | Only return stores with sample products at or below this price. Leave empty for no maximum. |
| `onSale` | boolean | `false` | Only return stores that have products currently on sale. |
| `inStock` | boolean | `false` | Only return stores that have products currently in stock. |
| `shipsFrom` | boolean | `false` | Only return stores that ship from the chosen store location (local sellers), rather than stores that merely ship to it. |

### Output

Each store is one flat row — ready for a CRM import or a spreadsheet. Contact, address, and social fields are surfaced at the top level, with the full structured objects (`address`, `contacts`, `sampleProducts`) attached for power users.

```json
{
    "id": "gid://shopify/Shop/12345678",
    "name": "Bright Roast Coffee Co.",
    "websiteUrl": "https://brightroastcoffee.com",
    "myshopifyDomain": "bright-roast-coffee.myshopify.com",
    "shareUrl": "https://store-listing.example/stores/bright-roast-coffee",
    "defaultHandle": "bright-roast-coffee",
    "shopifyId": "12345678",
    "rating": 4.8,
    "totalProductRatings": 1240,
    "totalProductReviews": 312,
    "email": "hello@brightroastcoffee.com",
    "phone": "+1 305-555-0142",
    "contactUrl": "https://brightroastcoffee.com/pages/contact",
    "city": "Miami",
    "country": "United States",
    "facebook": "https://facebook.com/brightroastcoffee",
    "instagram": "https://instagram.com/brightroastcoffee",
    "pinterest": "https://pinterest.com/brightroastcoffee",
    "youtube": null,
    "twitter": "https://twitter.com/brightroast",
    "tiktok": "https://tiktok.com/@brightroastcoffee",
    "address": {
        "address1": "2814 Northwest 72nd Avenue",
        "city": "Miami",
        "zone": "Florida",
        "country": "United States",
        "postalCode": "33122",
        "formatted": ["2814 Northwest 72nd Avenue", "Miami, Florida 33122", "United States"]
    },
    "contacts": [
        { "method": "email", "target": "hello@brightroastcoffee.com" },
        { "method": "instagram", "target": "https://instagram.com/brightroastcoffee" }
    ],
    "sampleProducts": [
        {
            "title": "Single-Origin Ethiopia — Whole Bean 12oz",
            "price": "18.00",
            "currency": "USD",
            "url": "https://brightroastcoffee.com/products/single-origin-ethiopia",
            "imageUrl": "https://cdn.shopify.com/example.jpg"
        }
    ],
    "scrapedAt": "2026-06-11T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique store identifier |
| `name` | string | Store name |
| `websiteUrl` | string | The store's public storefront URL |
| `myshopifyDomain` | string | The store's `*.myshopify.com` domain |
| `shareUrl` | string | The store's marketplace listing URL |
| `defaultHandle` | string | The store's marketplace handle (slug) |
| `shopifyId` | string | The store's numeric Shopify identifier |
| `rating` | number | Aggregate store rating |
| `totalProductRatings` | number | Count of product ratings across the store |
| `totalProductReviews` | number | Count of product reviews across the store |
| `scrapedAt` | string | ISO timestamp of when the row was captured |

#### Contact

| Field | Type | Description |
|-------|------|-------------|
| `email` | string | Primary contact email — this is what qualifies a store as a billable lead |
| `phone` | string | Primary contact phone number |
| `contactUrl` | string | The store's published contact-page or contact-form URL, where available |
| `contacts` | object\[] | Every published contact method as `{ method, target }` pairs (email, phone, web, and social links) |

#### Address

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | Store city (mirrors `address.city`) |
| `country` | string | Store country (mirrors `address.country`) |
| `address` | object | Full postal address: `address1`, `city`, `zone`, `country`, `postalCode`, and the original `formatted` display lines |

#### Social Profiles

| Field | Type | Description |
|-------|------|-------------|
| `facebook` | string | Facebook page URL |
| `instagram` | string | Instagram profile URL |
| `pinterest` | string | Pinterest profile URL |
| `youtube` | string | YouTube channel URL |
| `twitter` | string | Twitter/X profile URL |
| `tiktok` | string | TikTok profile URL |

#### Sample Products

| Field | Type | Description |
|-------|------|-------------|
| `sampleProducts` | object\[] | 2–3 representative products, each with `title`, `price`, `currency`, `url`, and `imageUrl` |

### Tips for Best Results

- **Start small to preview the data** — run with `maxItems: 25` first to confirm the leads match your niche, then scale up to thousands.
- **Use a specific keyword for tighter results** — "single-origin coffee" returns more relevant stores than "coffee". Narrow keywords mean cleaner, more actionable lead lists.
- **A strict store location keeps searching until it fills your target** — the scraper counts only stores in your chosen location toward your maximum and keeps paging through results to reach it. If a region simply doesn't have that many stores for your keyword, you'll get fewer leads than requested — widen the keyword to find more. Stores whose country can't be resolved are dropped when you choose a specific location, so broad keywords pair best with tight locations.
- **Combine a keyword with a category to refine, not replace** — when you set both, the category sharpens the keyword search rather than overriding it.
- **Filter on store rating downstream to prioritize outreach** — sort your export by `rating` and `totalProductReviews` to reach established merchants first.
- **Treat ships-to as a soft preference** — it nudges results toward stores that ship to your chosen country but isn't a hard cutoff, so don't rely on it alone to scope a market.
- **Budget by email coverage, not store count** — only stores with an email count as paid leads. Roughly half of returned stores include one, so a 1,000-store run typically yields around 500 billable leads.

### Pricing

**Pay for leads, not lookups — $5.00 per 1,000 verified-email stores, plus $0.01 per 1,000 stores returned.** There are no compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Every store row is billed at the low result rate, and the lead rate applies only to the stores that actually include an email address you can contact.

| Charge | Rate | When it applies |
|--------|------|-----------------|
| Store returned | $0.01 per 1,000 | Every store row in your output |
| Verified-email lead | $5.00 per 1,000 | Only stores that include an email address |

The table below shows the total at a realistic email coverage. In practice about **half of returned stores include an email**, so the worked totals assume 50% of stores become billable leads:

| Stores returned | Verified-email leads (~50%) | Stores cost | Leads cost | Total |
|-----------------|-----------------------------|-------------|------------|-------|
| 100 | 50 | $0.001 | $0.25 | $0.25 |
| 1,000 | 500 | $0.01 | $2.50 | $2.51 |
| 10,000 | 5,000 | $0.10 | $25.00 | $25.10 |
| 100,000 | 50,000 | $1.00 | $250.00 | $251.00 |

A store with no email is only ever billed at the $0.01 result rate — you never pay the lead rate for an uncontactable store. Apify loyalty discounts (Bronze, Silver, Gold) apply on top of these rates, and platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate B2B lead generation, market research, and partnership prospecting using publicly listed Shopify store information. Users are responsible for complying with applicable laws — including marketing, anti-spam, and data-protection regulations such as GDPR and CAN-SPAM — and with the terms of service of the platforms involved. Do not use extracted contact details for spam, harassment, or any unlawful purpose. Always honor opt-out requests and obtain consent where required.

# Actor input Schema

## `query` (type: `string`):

A product keyword to discover stores selling that item, such as 'organic coffee', 'yoga mat', or 'scented candles'. Leave empty to browse a whole category instead.

## `category` (type: `string`):

Limit results to stores selling products in this category. Leave empty to search across all categories.

## `maxItems` (type: `integer`):

Maximum number of stores to return. Each store is one lead. Higher numbers take longer and cost more.

## `storeLocation` (type: `string`):

Only return stores based in this country or region. Choose 'Worldwide' to include stores from everywhere. A very strict location may return fewer than your maximum if there aren't that many stores in that region for your keyword.

## `shipsTo` (type: `string`):

Only return stores that ship to this country. Leave empty for no shipping filter.

## `priceMin` (type: `integer`):

Only return stores with sample products at or above this price. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Only return stores with sample products at or below this price. Leave empty for no maximum.

## `onSale` (type: `boolean`):

Only return stores that have products currently on sale.

## `inStock` (type: `boolean`):

Only return stores that have products currently in stock.

## `shipsFrom` (type: `boolean`):

Only return stores that ship from the chosen store location (local sellers), rather than stores that merely ship to it.

## Actor input object example

```json
{
  "query": "organic coffee",
  "category": "",
  "maxItems": 50,
  "storeLocation": "GLOBAL",
  "shipsTo": "",
  "onSale": false,
  "inStock": false,
  "shipsFrom": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of discovered Shopify stores with contact and location details.

# 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 = {
    "query": "organic coffee",
    "category": "",
    "maxItems": 50,
    "storeLocation": "GLOBAL",
    "shipsTo": "",
    "onSale": false,
    "inStock": false,
    "shipsFrom": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/shopify-store-leads-scraper").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 = {
    "query": "organic coffee",
    "category": "",
    "maxItems": 50,
    "storeLocation": "GLOBAL",
    "shipsTo": "",
    "onSale": False,
    "inStock": False,
    "shipsFrom": False,
}

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

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

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

```

## CLI example

```bash
echo '{
  "query": "organic coffee",
  "category": "",
  "maxItems": 50,
  "storeLocation": "GLOBAL",
  "shipsTo": "",
  "onSale": false,
  "inStock": false,
  "shipsFrom": false
}' |
apify call solidcode/shopify-store-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/shopify-store-leads-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Leads Scraper",
        "description": "[💰 $5 / 1K leads] Find Shopify stores by product keyword or category and turn them into sales leads — store name, website, email, phone, address, and Facebook, Instagram & TikTok profiles. You only pay for stores that include an email.",
        "version": "1.0",
        "x-build-id": "I2qV1Zxa1coVIM2dQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~shopify-store-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-shopify-store-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~shopify-store-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-shopify-store-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~shopify-store-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-shopify-store-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "A product keyword to discover stores selling that item, such as 'organic coffee', 'yoga mat', or 'scented candles'. Leave empty to browse a whole category instead."
                    },
                    "category": {
                        "title": "Product Category",
                        "enum": [
                            "",
                            "women",
                            "men",
                            "accessories",
                            "beauty",
                            "home",
                            "electronics",
                            "luggage-bags",
                            "toys-games",
                            "pet-supplies",
                            "fitness-nutrition",
                            "baby-toddler",
                            "food-drinks",
                            "sporting-goods",
                            "arts-crafts"
                        ],
                        "type": "string",
                        "description": "Limit results to stores selling products in this category. Leave empty to search across all categories.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Maximum Stores",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of stores to return. Each store is one lead. Higher numbers take longer and cost more.",
                        "default": 50
                    },
                    "storeLocation": {
                        "title": "Store Location",
                        "enum": [
                            "GLOBAL",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "IE",
                            "ENGLISH_SPEAKING",
                            "UK_IRELAND",
                            "EUROPE",
                            "NORTH_AMERICA",
                            "NORDICS",
                            "OCEANIA"
                        ],
                        "type": "string",
                        "description": "Only return stores based in this country or region. Choose 'Worldwide' to include stores from everywhere. A very strict location may return fewer than your maximum if there aren't that many stores in that region for your keyword.",
                        "default": "GLOBAL"
                    },
                    "shipsTo": {
                        "title": "Ships To",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "IE",
                            "FR",
                            "DE",
                            "ES",
                            "IT",
                            "NL",
                            "BE",
                            "PT",
                            "CH",
                            "AT",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "PL",
                            "CZ",
                            "HU",
                            "RO",
                            "GR",
                            "IS",
                            "JP",
                            "KR",
                            "CN",
                            "HK",
                            "TW",
                            "SG",
                            "MY",
                            "TH",
                            "ID",
                            "PH",
                            "VN",
                            "IN",
                            "BR",
                            "MX",
                            "AR",
                            "CL",
                            "CO",
                            "PE",
                            "AE",
                            "SA",
                            "IL",
                            "TR",
                            "ZA",
                            "EG"
                        ],
                        "type": "string",
                        "description": "Only return stores that ship to this country. Leave empty for no shipping filter.",
                        "default": ""
                    },
                    "priceMin": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return stores with sample products at or above this price. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return stores with sample products at or below this price. Leave empty for no maximum."
                    },
                    "onSale": {
                        "title": "On Sale Only",
                        "type": "boolean",
                        "description": "Only return stores that have products currently on sale.",
                        "default": false
                    },
                    "inStock": {
                        "title": "In Stock Only",
                        "type": "boolean",
                        "description": "Only return stores that have products currently in stock.",
                        "default": false
                    },
                    "shipsFrom": {
                        "title": "Local Sellers Only",
                        "type": "boolean",
                        "description": "Only return stores that ship from the chosen store location (local sellers), rather than stores that merely ship to it.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
