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

Scrape Shopify store leads by keyword or category. Extract emails, phone numbers, addresses, ratings, social links, and sample products. Filter by location, price, and shipping. Export as JSON, CSV, Excel.

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

## Pricing

from $2.70 / 1,000 store scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 — Emails, Phones & Ratings

Discover Shopify stores by product keyword or category and extract emails, phone numbers, addresses, ratings, social media links, and sample products — no store URL needed.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search by keyword, category, location, and price range — get emails, phones, physical addresses, ratings, social profiles, and sample products for every Shopify store in your niche, ready for B2B outreach, supplier discovery, or market research.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

Shopify Store Leads Scraper (parsebird/shopify-store-leads-scraper) discovers Shopify stores and extracts contact data. Call via ApifyClient: client.actor("parsebird/shopify-store-leads-scraper").call(run\_input={"query": "organic coffee", "maxItems": 50}). Inputs: query (string — product keyword), category (string — Shopify ProductCategory GID e.g. "gid://shopify/ProductCategory/7" for Electronics), storeLocation (string — country code like "US"/"GB" or region like "EUROPE"/"ENGLISH\_SPEAKING"/"GLOBAL"), maxItems (int, 1–10000, default 50), priceMin (int), priceMax (int), onSale (bool), inStock (bool), shipsFrom (bool), shipsTo (string — country code). Output fields: id, name, websiteUrl, myshopifyDomain, shareUrl, address (city, zone, country, phone, company), contacts (web, email, phone, facebook, instagram, pinterest, youtube, twitter, tiktok), rating, totalProductReviews, sampleProducts (title, price, currency, url, imageUrl), scrapedAt. Pricing: $3.70/1,000 stores (Free/Bronze/Silver), $2.70/1,000 (Gold). Get API token: https://console.apify.com/account#/integrations

````

### What does Shopify Store Leads Scraper do?

Shopify Store Leads Scraper finds Shopify stores by product keyword or category and extracts structured contact data at scale. It searches the [Shop by Shopify](https://shop.app) marketplace to discover stores, then enriches each one with metadata and contact information scraped directly from their websites.

- 🔍 **Search by keyword** — Enter what stores sell (e.g. "organic coffee", "yoga mats", "wireless headphones") to find matching Shopify stores
- 📂 **Browse by category** — Pick from 14 product categories (Women, Men, Electronics, Beauty, Home, and more) to discover all stores in a niche
- 🌍 **Filter by location** — Target stores in a specific country (US, GB, DE, FR...), a region (Europe, North America, English-speaking), or worldwide
- 📧 **Extract emails and phones** — Automated contact discovery from store websites, including `tel:` links and email addresses
- 📱 **Social media profiles** — Facebook, Instagram, Pinterest, YouTube, TikTok, Twitter/X, and LinkedIn links
- ⭐ **Ratings and reviews** — Store ratings and total product review counts from the Shopify marketplace
- 🏬 **Store metadata** — Business name, city, state/province, country, Shopify domain, and website URL
- 🛍️ **Sample products** — Up to 3 sample products per store with titles, prices, URLs, and images
- 💰 **Price and availability filters** — Filter by minimum/maximum product price, on-sale items, or in-stock products
- 📦 **Shipping filters** — Find stores that ship to or from specific countries

### What data can you extract from Shopify stores?

| Data Field | Type | Description |
|------------|------|-------------|
| **name** | string | Store business name |
| **websiteUrl** | string | Store's primary website URL |
| **myshopifyDomain** | string | Shopify domain (e.g. store-name.myshopify.com) |
| **shareUrl** | string | Shop app profile URL |
| **address** | object | City, state/province, country, company name, phone |
| **contacts** | array | Web, email, phone, Facebook, Instagram, Pinterest, YouTube, Twitter, TikTok, LinkedIn |
| **rating** | number | Average product rating (out of 5) |
| **totalProductReviews** | number | Total product review count |
| **sampleProducts** | array | Up to 3 products with title, price, currency, URL, and image |
| **scrapedAt** | string | ISO timestamp of when the data was scraped |

### How to find Shopify stores

1. **Open the Actor** — Go to [Shopify Store Leads Scraper](https://apify.com/parsebird/shopify-store-leads-scraper) on Apify Console
2. **Enter a product keyword** — Type what the stores sell (e.g. "organic coffee", "yoga mats", "wireless headphones") or select a category
3. **Set filters** — Optionally add a store location, price range, or shipping filters
4. **Set your limit** — Choose how many stores to return (default: 50, max: 10,000)
5. **Click Start** — The scraper discovers Shopify stores and enriches each one with contact data
6. **Download your data** — Export as JSON, CSV, Excel, or HTML from the dataset tab, or connect via API

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| query | string | No* | — | Product keyword to search for stores |
| category | string | No* | — | Product category filter (14 categories) |
| storeLocation | string | No | — | Country code (US, GB, DE...) or region (EUROPE, NORTH_AMERICA...) |
| maxItems | integer | No | 50 | Maximum stores to return (1–10,000) |
| priceMin | integer | No | — | Only stores selling products above this price |
| priceMax | integer | No | — | Only stores selling products below this price |
| onSale | boolean | No | false | Only stores with products on sale |
| inStock | boolean | No | false | Only stores with products in stock |
| shipsFrom | boolean | No | false | Only local sellers |
| shipsTo | string | No | — | Only stores shipping to a specific country |

*At least one of `query` or `category` is required.

**Category values** (for API users):

| Category | Value |
|----------|-------|
| Women | `gid://shopify/ProductCategory/1` |
| Men | `gid://shopify/ProductCategory/2` |
| Accessories | `gid://shopify/ProductCategory/3` |
| Beauty | `gid://shopify/ProductCategory/5` |
| Home | `gid://shopify/ProductCategory/6` |
| Electronics | `gid://shopify/ProductCategory/7` |
| Luggage & bags | `gid://shopify/ProductCategory/9` |
| Toys & games | `gid://shopify/ProductCategory/10` |
| Pet supplies | `gid://shopify/ProductCategory/15` |
| Fitness & nutrition | `gid://shopify/ProductCategory/69` |
| Baby & toddler | `gid://shopify/ProductCategory/209` |
| Food & drinks | `gid://shopify/ProductCategory/251` |
| Sporting goods | `gid://shopify/ProductCategory/267` |
| Arts & crafts | `gid://shopify/ProductCategory/285` |

**Store location values** (for API users):

| Region | Value |
|--------|-------|
| English-speaking | `ENGLISH_SPEAKING` |
| Europe | `EUROPE` |
| North America | `NORTH_AMERICA` |
| UK & Ireland | `UK_IRELAND` |
| Nordics | `NORDICS` |
| Oceania | `OCEANIA` |
| Worldwide | `GLOBAL` |

For a single country, use its two-letter code: `US`, `GB`, `CA`, `AU`, `NZ`, `IE`, `DE`, `FR`, `IT`, `ES`, `NL`, `PL`, `AT`, `CH`, `PT`, `SE`, `DK`, `FI`.

### Output example

Each store in the dataset includes contact data, address, ratings, and sample products:

```json
{
    "id": "83224756522",
    "name": "Café Britt",
    "websiteUrl": "https://www.cafebritt.com",
    "myshopifyDomain": "faabaa-2.myshopify.com",
    "shareUrl": "https://shop.app/m/faabaa-2",
    "address": {
        "address1": null,
        "address2": null,
        "city": "Miami",
        "zone": "Florida",
        "zoneCode": null,
        "country": "US",
        "postalCode": null,
        "company": "Café Britt",
        "phone": "1-800-462-7488",
        "formatted": ["Miami Florida", "US"]
    },
    "contacts": [
        { "method": "web", "target": "https://www.cafebritt.com" },
        { "method": "email", "target": "info@britt.com" },
        { "method": "phone", "target": "1-800-462-7488" },
        { "method": "facebook", "target": "https://www.facebook.com/BrittGourmetCoffee" },
        { "method": "instagram", "target": "https://www.instagram.com/cafebritt_us" },
        { "method": "pinterest", "target": "https://www.pinterest.com/cafebritt" },
        { "method": "youtube", "target": "https://www.youtube.com/Cafebritt" },
        { "method": "tiktok", "target": "https://www.tiktok.com/@cafebritt" },
        { "method": "twitter", "target": "https://x.com/CafeBritt" }
    ],
    "rating": 4.9,
    "totalProductReviews": 699,
    "sampleProducts": [
        {
            "title": "COSTA RICAN ORGANIC COFFEE",
            "price": 22.95,
            "currency": "USD",
            "url": "https://www.cafebritt.com/products/costa-rican-organic-coffee",
            "imageUrl": "https://cdn.shopify.com/s/files/1/0832/2475/6522/files/OrganicoMockup-Front-grano.webp"
        }
    ],
    "scrapedAt": "2026-06-20T09:04:30.195077+00:00"
}
````

Download results in **JSON, CSV, Excel, or HTML** directly from the [Apify dataset](https://docs.apify.com/platform/storage/dataset).

### Use cases

**B2B lead generation** — Build targeted prospect lists of Shopify store owners by niche and location. Get direct contact details (email, phone, social media) for outreach campaigns. Filter by country or region to target specific markets.

**Supplier discovery** — Find stores selling specific products across the Shopify ecosystem. Compare pricing, ratings, and product ranges to identify potential suppliers or wholesale partners.

**Competitor research** — Map the competitive landscape for any product category. Analyze store ratings, review volumes, and geographic distribution to understand market dynamics.

**Market intelligence** — Identify trending niches by searching different product keywords. Track how many stores operate in each category and where they're located.

**Agency prospecting** — Discover Shopify stores in specific verticals and build outreach lists for e-commerce agency services — design, marketing, fulfillment, or app development.

### How much does it cost to scrape Shopify store leads?

Shopify Store Leads Scraper uses pay-per-event pricing — you only pay for stores delivered, not compute time.

| Tier | Per 1,000 stores | Per store |
|------|------------------:|----------:|
| Free / Bronze / Silver | $3.70 | $0.0037 |
| Gold | $2.70 | $0.0027 |

**Example:** Discovering 500 Shopify stores selling "organic coffee" costs $1.85 on the Free tier, or $1.35 on Gold.

New users get a [free trial](https://apify.com/pricing) with $5 of platform credits to test any Actor.

See the [Pricing tab](https://apify.com/parsebird/shopify-store-leads-scraper/pricing) for current rates.

### Programmatic API usage

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "query": "organic coffee",
    "maxItems": 200,
    "storeLocation": "US",
}

run = client.actor("parsebird/shopify-store-leads-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} — {item['rating']}/5 — {item.get('address', {}).get('city', 'N/A')}")
    for contact in item.get("contacts", []):
        if contact["method"] == "email":
            print(f"  Email: {contact['target']}")
```

#### JavaScript

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "<YOUR_API_TOKEN>" });

const input = {
    query: "organic coffee",
    maxItems: 200,
    storeLocation: "US",
};

const run = await client.actor("parsebird/shopify-store-leads-scraper").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

items.forEach((item) => {
    console.log(`${item.name} — ${item.rating}/5 — ${item.address?.city || "N/A"}`);
    item.contacts?.filter((c) => c.method === "email").forEach((c) => {
        console.log(`  Email: ${c.target}`);
    });
});
```

Get your API token at [Apify Console → Integrations](https://console.apify.com/account#/integrations).

Use [Apify scheduling](https://docs.apify.com/platform/schedules) to run daily, weekly, or at any interval. Combine with [integrations](https://apify.com/integrations) to push results to Google Sheets, Slack, webhooks, or your database.

### Is it legal to scrape Shopify store data?

Shopify Store Leads Scraper accesses **publicly available data** from the [Shop by Shopify](https://shop.app) marketplace and individual Shopify store websites. All information extracted — store names, contact details, social media links, ratings — is visible to any visitor without authentication.

This Actor does not access private accounts, bypass authentication, or collect non-public personal data. It processes only the same public business data available to any browser visitor.

As with any data collection tool, users should review [Shopify's terms of service](https://www.shopify.com/legal/terms) and ensure their specific use case complies with applicable regulations. For more context on web scraping legality, see [Apify's guide on web scraping and the law](https://blog.apify.com/is-web-scraping-legal/).

### Related Actors

Explore more ParseBird data extraction tools on the [Apify Store](https://apify.com/parsebird):

- [Product Hunt Scraper](https://apify.com/parsebird/product-hunt-scraper) — Extract Product Hunt launches, leaderboards, upvotes, reviews, and maker emails
- [Pappers.fr Company Scraper](https://apify.com/parsebird/pappers-scraper) — Extract French company data with SIREN, directors, and legal forms
- [Fotocasa Scraper](https://apify.com/parsebird/fotocasa-scraper) — Scrape Spanish real estate listings from Fotocasa.es
- [HTTP Request Actor](https://apify.com/parsebird/http-request-actor) — Send custom HTTP requests with full control over headers, method, and body
- [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — Remove duplicate records from any Apify dataset

### FAQ

**How many stores can I find?**
Up to 10,000 per run. Set `maxItems` to control how many stores you want. The scraper uses multiple search variations to discover as many unique stores as possible for your query.

**Can I discover all stores in a category?**
Yes. Select a category and leave the search query empty. The scraper automatically searches the category using relevant product keywords to find stores. Set `maxItems` to control how many stores you want.

**What contact data is included?**
Each store includes all available contact channels discovered from their website: website URL, email addresses, phone numbers (from `tel:` links), plus social media profiles (Facebook, Instagram, Pinterest, YouTube, TikTok, Twitter/X, LinkedIn).

**Do I need a store URL?**
No. This scraper discovers stores by product keyword or category. Just describe what you're looking for — no prior list of store URLs is needed.

**Can I filter by location?**
Yes. Set `storeLocation` to find stores based in a specific country or region. Single countries use two-letter codes (e.g. `US`, `GB`, `DE`). Regions include `ENGLISH_SPEAKING`, `EUROPE`, `NORTH_AMERICA`, `UK_IRELAND`, `NORDICS`, `OCEANIA`, and `GLOBAL`.

**Is the data fresh?**
Yes. Every run performs live searches. Results reflect current store info, ratings, and contact details at the time of scraping. Nothing is cached or pre-scraped.

**Can I export the data?**
Yes. Download as JSON, CSV, Excel, XML, or HTML from Apify Console. Access results via the [Apify API](https://docs.apify.com/api/v2) or integrate with [Google Sheets, Zapier, Make, or Airbyte](https://apify.com/integrations).

**Can I schedule recurring runs?**
Yes. Use [Apify scheduling](https://docs.apify.com/platform/schedules) to run daily, weekly, or at any custom interval. Combine with integrations to automate your lead pipeline.

**What happens if the search returns fewer stores than maxItems?**
The scraper uses multiple search variations (keyword + suffixes, individual words) to discover as many unique stores as possible. If there aren't enough matching stores for your query, the scraper returns all it found. Try broader keywords or remove filters to find more stores.

# Actor input Schema

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

Product keyword to search for stores. Leave empty to browse a category instead.<br><br>Examples: <code>organic coffee</code>, <code>yoga mat</code>, <code>wireless headphones</code>

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

Select a product category to discover stores. Works alone (finds all stores in the category) or combined with a search query to narrow results.

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

Find stores <b>based in</b> a specific country or region. Leave as <b>Any location</b> for no location targeting.<br><br><b>For non-English markets</b> (Germany, France, Italy, etc.), search using local-language terms for best results.

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

Maximum number of unique stores to return.

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

Only discover stores selling products above this price (in USD).

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

Only discover stores selling products below this price (in USD).

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

Only discover stores with products currently on sale.

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

Only discover stores with products currently in stock.

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

Only discover stores that ship from the selected store location. Applied automatically when a store location is set.

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

Only discover stores that ship to a specific country.

## Actor input object example

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

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/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",
  "maxItems": 10
}' |
apify call parsebird/shopify-store-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Leads Scraper",
        "description": "Scrape Shopify store leads by keyword or category. Extract emails, phone numbers, addresses, ratings, social links, and sample products. Filter by location, price, and shipping. Export as JSON, CSV, Excel.",
        "version": "1.1",
        "x-build-id": "3bTMqFkJ2QqINgFXW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~shopify-store-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-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/parsebird~shopify-store-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-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/parsebird~shopify-store-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-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 query",
                        "type": "string",
                        "description": "Product keyword to search for stores. Leave empty to browse a category instead.<br><br>Examples: <code>organic coffee</code>, <code>yoga mat</code>, <code>wireless headphones</code>"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "gid://shopify/ProductCategory/1",
                            "gid://shopify/ProductCategory/2",
                            "gid://shopify/ProductCategory/3",
                            "gid://shopify/ProductCategory/5",
                            "gid://shopify/ProductCategory/6",
                            "gid://shopify/ProductCategory/7",
                            "gid://shopify/ProductCategory/9",
                            "gid://shopify/ProductCategory/10",
                            "gid://shopify/ProductCategory/15",
                            "gid://shopify/ProductCategory/69",
                            "gid://shopify/ProductCategory/209",
                            "gid://shopify/ProductCategory/251",
                            "gid://shopify/ProductCategory/267",
                            "gid://shopify/ProductCategory/285"
                        ],
                        "type": "string",
                        "description": "Select a product category to discover stores. Works alone (finds all stores in the category) or combined with a search query to narrow results.",
                        "default": ""
                    },
                    "storeLocation": {
                        "title": "Store location",
                        "enum": [
                            "",
                            "GLOBAL",
                            "ENGLISH_SPEAKING",
                            "EUROPE",
                            "NORTH_AMERICA",
                            "UK_IRELAND",
                            "NORDICS",
                            "OCEANIA",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "IE",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "PL",
                            "AT",
                            "CH",
                            "PT",
                            "SE",
                            "DK",
                            "FI"
                        ],
                        "type": "string",
                        "description": "Find stores <b>based in</b> a specific country or region. Leave as <b>Any location</b> for no location targeting.<br><br><b>For non-English markets</b> (Germany, France, Italy, etc.), search using local-language terms for best results.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max stores",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique stores to return.",
                        "default": 10
                    },
                    "priceMin": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only discover stores selling products above this price (in USD)."
                    },
                    "priceMax": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only discover stores selling products below this price (in USD)."
                    },
                    "onSale": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Only discover stores with products currently on sale.",
                        "default": false
                    },
                    "inStock": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only discover stores with products currently in stock.",
                        "default": false
                    },
                    "shipsFrom": {
                        "title": "Ships from store location",
                        "type": "boolean",
                        "description": "Only discover stores that ship from the selected store location. Applied automatically when a store location is set.",
                        "default": false
                    },
                    "shipsTo": {
                        "title": "Ships to country",
                        "enum": [
                            "",
                            "US",
                            "CA",
                            "GB",
                            "AU",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "BE",
                            "AT",
                            "CH",
                            "SE",
                            "DK",
                            "NO",
                            "FI",
                            "IE",
                            "PT",
                            "PL",
                            "CZ",
                            "RO",
                            "HU",
                            "GR",
                            "HR",
                            "BG",
                            "SK",
                            "SI",
                            "LT",
                            "LV",
                            "EE",
                            "IS",
                            "LU",
                            "NZ",
                            "JP",
                            "KR",
                            "SG",
                            "HK",
                            "TW",
                            "MY",
                            "PH",
                            "TH",
                            "ID",
                            "VN",
                            "IN",
                            "BR",
                            "MX",
                            "CO",
                            "AR",
                            "CL",
                            "ZA",
                            "AE",
                            "SA",
                            "IL",
                            "TR",
                            "NG",
                            "EG",
                            "KE"
                        ],
                        "type": "string",
                        "description": "Only discover stores that ship to a specific country.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
