# Shopify Product Scraper — Variants & Prices (`muhammadafzal/shopify-product-scraper`) Actor

Extract Shopify products, variants, prices, inventory signals, images, descriptions, and collections into structured ecommerce data.

- **URL**: https://apify.com/muhammadafzal/shopify-product-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Product Scraper — Variants & Prices

Extract complete product catalogs, collections, customer reviews, merchant contact info, and tech-stack intelligence from **any Shopify store** — no API key, no login, no browser automation required. Just enter a store domain and get clean, CRM-ready structured JSON.

> Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

### What It Extracts

#### 🛒 Products (one record per product)
- **Title, handle, brand/vendor, category, tags, description** — full product metadata
- **Pricing**: current price, original (compare-at) price, min/max variant price, **discount percentage**
- **Up to 250 variants** per product: SKU, barcode, price, availability, inventory quantity, weight, shipping flag, and options (Size, Color, etc.)
- **Images**: all image URLs, main image, image count, and alt texts for SEO analysis
- **Reviews summary**: aggregate rating, review count, review source, detected review platform
- **Sales estimates**: conservative monthly sales derived from review volume
- **Availability flags**: `available`, `fully_out_of_stock`, `requires_shipping`
- **Timestamps**: published_at, created_at, updated_at + `scraped_at` and `source_url` for traceability

#### 📂 Collections (one record per collection)
- Collection title, handle, description, product count, hero image, and canonical collection URL
- Useful for understanding store taxonomy and category structure

#### ⭐ Customer Reviews (one record per review)
- Reviewer name, star rating, review title, full review body, submission date
- Verified-buyer flag and helpful votes where available
- **Auto-detects review platforms**: Judge.me, Yotpo, Loox, Stamped, Okendo, Reviews.io, and JSON-LD
- Falls back to JSON-LD structured reviews when no widget is detected

#### 📧 Merchant Contact Info (one record per store)
- **Business email** and **phone number** — high-value for B2B lead generation
- Physical address, store currency, and language
- **Social media links**: Facebook, Instagram, Twitter/X, TikTok, YouTube, Pinterest
- Contact page URL

#### 🏪 Store Intelligence (one record per store)
- **Installed app detection**: Klaviyo, Mailchimp, Privy, ReCharge, Smile.io, Gorgias, Hotjar, Google Analytics, Facebook Pixel, TikTok Pixel, and 40+ more
- Apps grouped by category: Email Marketing, SMS, Reviews, Subscriptions, Loyalty, Analytics, Customer Service, Page Builder, Upsell, Search, etc.
- **Theme metadata**: theme name, version, and ID
- Shop name, currency, language, country, and domain

### Input Modes

#### URL Mode (default) — scrape known stores

Use this when you already know the Shopify stores to scrape:

```json
{
  "mode": "url",
  "storeUrls": [{ "url": "https://www.allbirds.com" }],
  "maxProducts": 100,
  "includeReviews": true,
  "scrapeCollections": true,
  "scrapeContactInfo": true,
  "scrapeTechStack": true
}
````

#### Discovery Mode — find stores by category first

Use this when you want to discover Shopify stores by niche, then scrape them:

```json
{
  "mode": "discovery",
  "category": "fashion",
  "maxStores": 25,
  "maxPages": 3,
  "maxProducts": 50
}
```

### Use Cases

- **Competitor price monitoring**: track pricing changes, discounts, and sold-out products across rival Shopify stores
- **Dropshipping product research**: identify trending products, price points, and inventory levels
- **B2B lead generation**: collect merchant emails, phone numbers, and social links for sales outreach — the highest-ROI use case
- **Market research**: analyze full product catalogs for pricing, category structures, and brand positioning
- **Review sentiment analysis**: extract individual customer reviews for NLP and product-improvement insights
- **Tech-stack prospecting**: detect which apps and themes a store uses — perfect for agency sales and app developers
- **Price comparison**: aggregate product data from multiple Shopify stores for comparison engines
- **Catalog monitoring**: detect new products and stock changes by comparing runs over time

### Pricing

This actor uses **Pay-Per-Event** pricing — you only pay for what you get:

| Event | When Charged | Price |
|---|---|---:|
| Actor Start | Once per run | $0.001 |
| **Product Scraped** | Per product extracted (primary) | **$0.005** |
| Collection Scraped | Per collection extracted | $0.001 |
| Review Scraped | Per individual review extracted | $0.001 |
| Contact Info Scraped | Per store (email, phone, socials) | $0.010 |
| Store Intelligence | Per store (apps, theme, tech stack) | $0.010 |

**Typical run cost**: 100 products from one store ≈ $0.50. Adding contact info + tech stack ≈ $0.52 total.

Free-tier and local runs handle charge failures gracefully and still produce data.

### Output

Each dataset item is a stable, MCP-friendly JSON object discriminated by `recordType`. Example product record:

```json
{
  "recordType": "product",
  "store_url": "https://www.allbirds.com",
  "product_id": "101",
  "title": "Tree Runner",
  "brand": "Allbirds",
  "category": "Shoes",
  "current_price": 95,
  "original_price": 120,
  "discount_percentage": 21,
  "available": true,
  "fully_out_of_stock": false,
  "requires_shipping": true,
  "variant_count": 12,
  "options": ["Size", "Color"],
  "variants": [{ "variant_id": "201", "sku": "TR-8-GRN", "price": 95, "available": true }],
  "image_count": 8,
  "main_image": "https://cdn.shopify.com/...",
  "rating": 4.7,
  "review_count": 321,
  "review_platform": "judge.me",
  "estimated_monthly_sales": 8025,
  "currency": "USD",
  "product_url": "https://www.allbirds.com/products/tree-runner",
  "scraped_at": "2026-07-08T12:00:00.000Z",
  "source_url": "https://www.allbirds.com/products.json?limit=250&page=1"
}
```

Example contact record:

```json
{
  "recordType": "contact",
  "store_url": "https://www.allbirds.com",
  "merchant_name": "Allbirds",
  "merchant_email": "hello@allbirds.com",
  "merchant_phone": "+1-800-555-1234",
  "social_facebook": "https://facebook.com/allbirds",
  "social_instagram": "https://instagram.com/allbirds",
  "social_tiktok": "https://tiktok.com/@allbirds",
  "contact_page_url": "https://www.allbirds.com/contact",
  "scraped_at": "2026-07-08T12:00:00.000Z"
}
```

### How It Works

The actor scrapes Shopify's **public storefront JSON endpoints** (`/products.json`, `/collections.json`) and product pages — no API keys, no login, no browser automation. This makes it fast, reliable, and cheap to run.

1. **Products**: paginates through `/products.json` (250 per page) until the catalog is exhausted or `maxProducts` is reached
2. **Reviews**: fetches each product page, reads JSON-LD aggregate ratings, and auto-detects review widgets (Judge.me, Yotpo, Loox, etc.) for individual review extraction
3. **Collections**: paginates through `/collections.json` for category metadata
4. **Contact & Tech Stack**: fetches the store homepage once, extracts merchant info and detects 45+ installed apps from script/CDN signatures

All extraction is **best-effort** — if a store disables public endpoints or a review widget isn't detected, the actor still returns whatever data is available without crashing.

### Development

```bash
npm install
npm test
npm run build
npm run validate:schema
apify run
```

### Limitations

- **Password-protected stores** or stores that disable public `/products.json` endpoints may return zero products — this is a Shopify storefront setting, not a scraper limitation
- **Review extraction** depends on the review widget rendering in the HTML — some platforms load reviews via JavaScript after page load and may not appear in the static HTML
- **Sales estimates** are conservative heuristics based on review volume, NOT verified revenue data
- **App detection** is based on script/CDN signatures — apps that load lazily or via server-side rendering may not be detected

### Changelog

- **v1.1** — Added collections, individual reviews, merchant contact info, tech-stack/app detection, multi-record-type output, MCP-optimized schemas
- **v1.0** — Initial release: product catalog scraping with review summaries and sales estimates

### What is Shopify Product Scraper?

**Shopify Product Scraper** turns the target data into structured, reusable results on Apify. Use it when you need repeatable collection for ecommerce teams, pricing analysts, sellers, agencies, and competitive-intelligence workflows without maintaining a custom scraper or one-off integration. Run it manually, schedule recurring jobs, call it through the Apify API, or connect it to an AI agent through the Apify MCP server.

The Actor stores results in an Apify dataset, where they can be previewed and exported as JSON, CSV, Excel, XML, or RSS. Availability and completeness depend on the source, supplied inputs, public visibility, authentication requirements, and upstream rate limits.

### Use cases for Shopify Product Scraper

- Build structured datasets for research, reporting, enrichment, or monitoring.
- Automate repetitive collection with schedules, webhooks, and API calls.
- Feed clean records into spreadsheets, databases, CRMs, BI tools, AI agents, or RAG pipelines.
- Track changes over time by running the same validated input on a schedule.
- Replace fragile manual copy-and-paste work with a reproducible Apify workflow.

### How to use Shopify Product Scraper

1. Open the Actor input page and choose a focused, valid target.
2. Set a conservative result limit for the first run.
3. Start the Actor and inspect the dataset for coverage and field availability.
4. Export the results or connect the dataset to your downstream system.
5. Scale gradually and use scheduling, pagination, or proxies when supported.

#### Important input options

- `mode` — Choose URL mode when the user provides Shopify store URLs (https://www.allbirds.com). Choose discovery mode to find Shopify stores by category first. Default is url. Do NOT use discovery mod
- `storeUrls` — Use this field when the user provides one or more Shopify storefronts. Accepts store homepages such as https://www.allbirds.com; product paths are normalized to the store origin. Default scr
- `category` — Use this ONLY in discovery mode to filter Shopify stores by niche. Examples: fashion, skincare, food/coffee, electronics, pets. Leave empty to discover across all categories. This is NOT a p
- `maxStores` — Maximum stores to collect from the discovery directory before scraping products. Use a small number for tests (10). Default 100, max 5000. Only used in discovery mode.
- `maxPages` — Maximum discovery directory pages to inspect. Each page may contain many stores. Default 10, max 220. Only used in discovery mode, NOT for Shopify product pagination.
- `maxProducts` — Maximum products to extract from each Shopify store. Use 10 for quick tests, higher values for full catalog research. Default 100, max 10000. Applies per store, not across all stores.
- `includeReviews` — When enabled, fetches each product page and reads JSON-LD aggregate ratings. Adds rating, review\_count, review\_source, and estimated\_monthly\_sales fields to product records. Default true. Di
- `maxReviewsPerProduct` — Maximum individual customer reviews to extract per product (separate review records). Set to 0 to skip individual review extraction. Default 0 (off). Set 10-50 for sentiment analysis. Review

### API and automation example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/shopify-product-scraper').call({
  // Add the same input fields you use in the Apify Console.
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Related Apify Actors

Use these dedicated tools when a neighboring data source or workflow is a better match:

- [Etsy Scraper Pro — Products, Prices, Reviews & Shop Data](https://apify.com/muhammadafzal/etsy-scraper-pro)
- [Shopify Store Scraper - Products, Reviews & Emails](https://apify.com/muhammadafzal/shopify-store-scraper)
- [eBay Scraper — Product Listings, Prices & Seller Data](https://apify.com/muhammadafzal/ebay-scraper)
- [Instagram Followers & Following Scraper — With Cookies](https://apify.com/muhammadafzal/instagram-following-scraper)
- [Facebook Ads Library Scraper — Meta Ad Intelligence Tool](https://apify.com/muhammadafzal/facebook-ads-library-scraper)
- [Leads Finder Pro - B2B Leads with Emails \[Apollo Alternative\]](https://apify.com/muhammadafzal/leads-finder-pro)
- [Yellow Pages US Scraper — Business Leads & Reviews](https://apify.com/muhammadafzal/yellow-pages-us-scraper)
- [Justia Lawyer Directory Scraper — Attorney Leads](https://apify.com/muhammadafzal/justia-lawyer-directory-scraper)
- [Yellow Pages Australia Scraper — Business Leads & Reviews](https://apify.com/muhammadafzal/yellow-pages-au-scraper)
- [OpenTable Restaurants, Ratings & Reviews Scraper](https://apify.com/muhammadafzal/opentable-scraper)

### Frequently asked questions

#### How many results can I scrape with Shopify Product Scraper?

The practical total depends on the source, input limits, pagination, available records, run timeout, and upstream restrictions. Start with a small run, verify the output, and increase the limit gradually.

#### Can I integrate Shopify Product Scraper with other apps?

Yes. Use Apify integrations, webhooks, schedules, dataset exports, Make, Zapier, Google Sheets, cloud storage, or your own application.

#### Can I use Shopify Product Scraper with the Apify API?

Yes. Start runs with the Apify REST API or an official Apify client, then retrieve records from the run's default dataset. Keep your API token in a secret or environment variable.

#### Can I use Shopify Product Scraper through an MCP Server?

Yes. The Apify MCP server can expose the Actor to compatible AI clients and agents. Review the input and expected cost before allowing an autonomous workflow to run it at scale.

#### Do I need proxies?

It depends on the source and volume. Use the default configuration first. For larger or geographically sensitive jobs, select an appropriate proxy configuration only when the Actor supports it.

#### Is it legal to scrape this data?

Scraping rules vary by source, jurisdiction, data type, and intended use. Collect only data you are authorized to access, respect applicable terms and privacy laws, and avoid restricted or personal data misuse. This documentation is not legal advice.

#### Your feedback

If a field is missing, a source layout has changed, or you need a supported use case documented, open an issue on the Actor page with a reproducible input and run ID.

# Actor input Schema

## `mode` (type: `string`):

Choose URL mode when the user provides Shopify store URLs (https://www.allbirds.com). Choose discovery mode to find Shopify stores by category first. Default is url. Do NOT use discovery mode for scraping a known store.

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

Use this field when the user provides one or more Shopify storefronts. Accepts store homepages such as https://www.allbirds.com; product paths are normalized to the store origin. Default scrapes Allbirds so health checks produce output. NOT used in discovery mode.

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

Use this ONLY in discovery mode to filter Shopify stores by niche. Examples: fashion, skincare, food/coffee, electronics, pets. Leave empty to discover across all categories. This is NOT a product category filter inside one store.

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

Maximum stores to collect from the discovery directory before scraping products. Use a small number for tests (10). Default 100, max 5000. Only used in discovery mode.

## `maxPages` (type: `integer`):

Maximum discovery directory pages to inspect. Each page may contain many stores. Default 10, max 220. Only used in discovery mode, NOT for Shopify product pagination.

## `maxProducts` (type: `integer`):

Maximum products to extract from each Shopify store. Use 10 for quick tests, higher values for full catalog research. Default 100, max 10000. Applies per store, not across all stores.

## `includeReviews` (type: `boolean`):

When enabled, fetches each product page and reads JSON-LD aggregate ratings. Adds rating, review\_count, review\_source, and estimated\_monthly\_sales fields to product records. Default true. Disable for faster catalog-only runs.

## `maxReviewsPerProduct` (type: `integer`):

Maximum individual customer reviews to extract per product (separate review records). Set to 0 to skip individual review extraction. Default 0 (off). Set 10-50 for sentiment analysis. Reviews are detected from Judge.me, Yotpo, Loox, Stamped, Okendo, and JSON-LD.

## `scrapeCollections` (type: `boolean`):

When enabled, extracts all store collections (categories) from /collections.json. Each collection is returned as a separate record with title, handle, description, product count, and image. Default false.

## `maxCollections` (type: `integer`):

Maximum collections to extract per store when scrapeCollections is enabled. Default 250, max 5000. Large stores may have thousands of collections.

## `scrapeContactInfo` (type: `boolean`):

When enabled, extracts merchant email, phone, address, and social media links (Facebook, Instagram, Twitter/X, TikTok, YouTube, Pinterest) from the store homepage. Returns one contact record per store. High value for B2B lead generation. Default false.

## `scrapeTechStack` (type: `boolean`):

When enabled, detects installed Shopify apps (Klaviyo, Yotpo, Judge.me, ReCharge, Smile.io, Gorgias, etc.), theme metadata, and store intelligence from the homepage. Returns one storeIntel record per store. Default false.

## `reviewConversionRate` (type: `number`):

Estimated share of buyers who leave reviews, used to convert review counts into conservative monthly sales estimates. Example: 0.02 means 2% of buyers review. Default 0.02. This is an estimate, NOT verified revenue data.

## `requestDelayMs` (type: `integer`):

Delay between successful HTTP requests. Use 0 for fastest runs or 500-2000 for gentler scraping on larger catalogs. Default 500, max 10000. This is NOT a timeout setting.

## `maxRequestRetries` (type: `integer`):

Retry attempts for temporary HTTP, proxy, or network failures. Default 3, max 10. A 404 product catalog still produces no products rather than retrying forever. Does NOT bypass private stores or password walls.

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

Apify proxy settings for large catalogs or protected storefronts. The default uses Apify Proxy for better reliability. Use custom proxy URLs only when you need a dedicated premium proxy. Optional for small public Shopify stores.

## Actor input object example

```json
{
  "mode": "url",
  "storeUrls": [
    {
      "url": "https://www.allbirds.com"
    }
  ],
  "category": "fashion",
  "maxStores": 25,
  "maxPages": 3,
  "maxProducts": 25,
  "includeReviews": true,
  "maxReviewsPerProduct": 0,
  "scrapeCollections": false,
  "maxCollections": 250,
  "scrapeContactInfo": false,
  "scrapeTechStack": false,
  "reviewConversionRate": 0.02,
  "requestDelayMs": 500,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Link to the dataset containing all scraped Shopify records (products, collections, reviews, contact info, store intelligence).

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

Link to the SUMMARY key-value store record with mode, store count, and counts per record type (products, collections, reviews, contacts, store intel).

# 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 = {
    "mode": "url",
    "storeUrls": [
        {
            "url": "https://www.allbirds.com"
        }
    ],
    "category": "fashion",
    "maxStores": 25,
    "maxPages": 3,
    "maxProducts": 25,
    "includeReviews": true,
    "maxReviewsPerProduct": 0,
    "scrapeCollections": false,
    "maxCollections": 250,
    "scrapeContactInfo": false,
    "scrapeTechStack": false,
    "reviewConversionRate": 0.02
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/shopify-product-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 = {
    "mode": "url",
    "storeUrls": [{ "url": "https://www.allbirds.com" }],
    "category": "fashion",
    "maxStores": 25,
    "maxPages": 3,
    "maxProducts": 25,
    "includeReviews": True,
    "maxReviewsPerProduct": 0,
    "scrapeCollections": False,
    "maxCollections": 250,
    "scrapeContactInfo": False,
    "scrapeTechStack": False,
    "reviewConversionRate": 0.02,
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/shopify-product-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 '{
  "mode": "url",
  "storeUrls": [
    {
      "url": "https://www.allbirds.com"
    }
  ],
  "category": "fashion",
  "maxStores": 25,
  "maxPages": 3,
  "maxProducts": 25,
  "includeReviews": true,
  "maxReviewsPerProduct": 0,
  "scrapeCollections": false,
  "maxCollections": 250,
  "scrapeContactInfo": false,
  "scrapeTechStack": false,
  "reviewConversionRate": 0.02
}' |
apify call muhammadafzal/shopify-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Product Scraper — Variants & Prices",
        "description": "Extract Shopify products, variants, prices, inventory signals, images, descriptions, and collections into structured ecommerce data.",
        "version": "1.0",
        "x-build-id": "ugYamVeTxnC2fpl5k"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~shopify-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-shopify-product-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/muhammadafzal~shopify-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-shopify-product-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/muhammadafzal~shopify-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-shopify-product-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "url",
                            "discovery"
                        ],
                        "type": "string",
                        "description": "Choose URL mode when the user provides Shopify store URLs (https://www.allbirds.com). Choose discovery mode to find Shopify stores by category first. Default is url. Do NOT use discovery mode for scraping a known store.",
                        "default": "url"
                    },
                    "storeUrls": {
                        "title": "Shopify Store URLs",
                        "type": "array",
                        "description": "Use this field when the user provides one or more Shopify storefronts. Accepts store homepages such as https://www.allbirds.com; product paths are normalized to the store origin. Default scrapes Allbirds so health checks produce output. NOT used in discovery mode.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "Store URL",
                                    "description": "A Shopify store homepage or product URL, for example https://www.allbirds.com. The actor normalizes product paths to the store origin before scraping."
                                }
                            }
                        },
                        "default": [
                            {
                                "url": "https://www.allbirds.com"
                            }
                        ]
                    },
                    "category": {
                        "title": "Discovery Category",
                        "enum": [
                            "",
                            "fashion",
                            "fashion/shoes",
                            "fashion/jewellery",
                            "fashion/bags",
                            "fashion/lingerie",
                            "fashion/outerwear",
                            "fashion/swimwear",
                            "fashion/activewear",
                            "fashion/kids",
                            "beauty",
                            "skincare",
                            "skincare/serum",
                            "skincare/mask",
                            "skincare/cleanser",
                            "skincare/sunscreen",
                            "skincare/acne",
                            "skincare/toner",
                            "skincare/exfoliant",
                            "haircare",
                            "haircare/shampoo",
                            "haircare/conditioner",
                            "haircare/styling",
                            "haircare/tools",
                            "food",
                            "food/snack",
                            "food/candy",
                            "food/bakery",
                            "food/meat",
                            "food/seafood",
                            "food/vegan",
                            "food/organic",
                            "food/glutenfree",
                            "food/coffee",
                            "food/tea",
                            "food/alcohol",
                            "electronics",
                            "electronics/phone",
                            "electronics/computer",
                            "electronics/camera",
                            "electronics/audio",
                            "electronics/wearable",
                            "home",
                            "home/furniture",
                            "home/lighting",
                            "home/decor",
                            "home/storage",
                            "kitchen",
                            "kitchen/appliance",
                            "kitchen/cookware",
                            "kitchen/utensil",
                            "kitchen/storage",
                            "kitchen/tableware",
                            "kitchen/drinkware",
                            "sports",
                            "sports/equipment",
                            "sports/clothing",
                            "pets",
                            "pets/food",
                            "pets/accessory",
                            "pets/health",
                            "baby",
                            "baby/clothing",
                            "baby/gear",
                            "baby/feeding",
                            "baby/toys",
                            "bedding",
                            "bathroom",
                            "bath-body",
                            "dental",
                            "eyewear",
                            "watches",
                            "bags",
                            "accessories",
                            "gifts",
                            "flowers",
                            "party",
                            "books",
                            "music",
                            "art",
                            "crafts",
                            "outdoors",
                            "automotive",
                            "tools",
                            "office",
                            "safety",
                            "cleaning",
                            "energy",
                            "alcohol"
                        ],
                        "type": "string",
                        "description": "Use this ONLY in discovery mode to filter Shopify stores by niche. Examples: fashion, skincare, food/coffee, electronics, pets. Leave empty to discover across all categories. This is NOT a product category filter inside one store.",
                        "default": ""
                    },
                    "maxStores": {
                        "title": "Max Stores to Discover",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum stores to collect from the discovery directory before scraping products. Use a small number for tests (10). Default 100, max 5000. Only used in discovery mode.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max Discovery Pages",
                        "minimum": 1,
                        "maximum": 220,
                        "type": "integer",
                        "description": "Maximum discovery directory pages to inspect. Each page may contain many stores. Default 10, max 220. Only used in discovery mode, NOT for Shopify product pagination.",
                        "default": 10
                    },
                    "maxProducts": {
                        "title": "Max Products per Store",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum products to extract from each Shopify store. Use 10 for quick tests, higher values for full catalog research. Default 100, max 10000. Applies per store, not across all stores.",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Include Review Summaries & Sales Estimates",
                        "type": "boolean",
                        "description": "When enabled, fetches each product page and reads JSON-LD aggregate ratings. Adds rating, review_count, review_source, and estimated_monthly_sales fields to product records. Default true. Disable for faster catalog-only runs.",
                        "default": true
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews per Product (individual)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum individual customer reviews to extract per product (separate review records). Set to 0 to skip individual review extraction. Default 0 (off). Set 10-50 for sentiment analysis. Reviews are detected from Judge.me, Yotpo, Loox, Stamped, Okendo, and JSON-LD.",
                        "default": 0
                    },
                    "scrapeCollections": {
                        "title": "Scrape Collections",
                        "type": "boolean",
                        "description": "When enabled, extracts all store collections (categories) from /collections.json. Each collection is returned as a separate record with title, handle, description, product count, and image. Default false.",
                        "default": false
                    },
                    "maxCollections": {
                        "title": "Max Collections per Store",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum collections to extract per store when scrapeCollections is enabled. Default 250, max 5000. Large stores may have thousands of collections.",
                        "default": 250
                    },
                    "scrapeContactInfo": {
                        "title": "Scrape Merchant Contact Info",
                        "type": "boolean",
                        "description": "When enabled, extracts merchant email, phone, address, and social media links (Facebook, Instagram, Twitter/X, TikTok, YouTube, Pinterest) from the store homepage. Returns one contact record per store. High value for B2B lead generation. Default false.",
                        "default": false
                    },
                    "scrapeTechStack": {
                        "title": "Detect Installed Apps & Tech Stack",
                        "type": "boolean",
                        "description": "When enabled, detects installed Shopify apps (Klaviyo, Yotpo, Judge.me, ReCharge, Smile.io, Gorgias, etc.), theme metadata, and store intelligence from the homepage. Returns one storeIntel record per store. Default false.",
                        "default": false
                    },
                    "reviewConversionRate": {
                        "title": "Review Conversion Rate",
                        "minimum": 0.001,
                        "maximum": 1,
                        "type": "number",
                        "description": "Estimated share of buyers who leave reviews, used to convert review counts into conservative monthly sales estimates. Example: 0.02 means 2% of buyers review. Default 0.02. This is an estimate, NOT verified revenue data.",
                        "default": 0.02
                    },
                    "requestDelayMs": {
                        "title": "Request Delay Milliseconds",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between successful HTTP requests. Use 0 for fastest runs or 500-2000 for gentler scraping on larger catalogs. Default 500, max 10000. This is NOT a timeout setting.",
                        "default": 500
                    },
                    "maxRequestRetries": {
                        "title": "Max Request Retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for temporary HTTP, proxy, or network failures. Default 3, max 10. A 404 product catalog still produces no products rather than retrying forever. Does NOT bypass private stores or password walls.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Settings",
                        "type": "object",
                        "description": "Apify proxy settings for large catalogs or protected storefronts. The default uses Apify Proxy for better reliability. Use custom proxy URLs only when you need a dedicated premium proxy. Optional for small public Shopify stores.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
