# Shopify Scraper - Products, Prices, Variants & SKUs (`sonic_scraper/shopify-product-price-monitor`) Actor

Shopify scraper for any public store: export full catalogs with prices, compare-at sale prices, discounts, every variant with SKU and stock status, images, vendors, product types and tags. Bulk stores per run, only-discounted filter, no Shopify API key.

- **URL**: https://apify.com/sonic_scraper/shopify-product-price-monitor.md
- **Developed by:** [Group Oject](https://apify.com/sonic_scraper) (community)
- **Categories:** E-commerce, Automation, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 products

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Shopify Scraper - Products, Prices, Variants & SKUs

Scrape the full product catalog of any public **Shopify store**: titles, prices, compare-at (sale) prices, discounts, every variant with SKU and stock status, images, vendors, product types, and tags. Paste store URLs, click Start, and export to JSON, CSV, or Excel. **No Shopify API key and no store login.**

![Shopify Scraper output in Apify: store, product, vendor, type, price, compare at, discount %](https://api.apify.com/v2/key-value-stores/lwQu1lCMCLQIIhSMQ/records/shopify-product-price-monitor-output.png)

*Real output from a default run of Shopify Scraper in Apify Console.*

### What can this Shopify scraper do?

- **Scrape whole catalogs** - up to 5,000 products per store and 20,000 per run, paginated automatically.
- **Many stores in one run** - paste store URLs or bare domains (`allbirds.com`), one per line; up to 10 stores in parallel.
- **Variant-level data** - SKU, price, compare-at price, availability, and option values (size, color, etc.) for every variant.
- **Sale and discount detection** - `discountPercent` from compare-at vs. current price; optionally output **only discounted** products.
- **In-stock filter** - output only products with at least one available variant.
- **Clear failures** - stores that are not Shopify or block their product feed are reported in `ERRORS` and are not charged.
- **Lightweight** - plain HTTP against Shopify's public product feed, no browser, fast and cheap.

### What data can I extract from Shopify stores?

| Field | Description |
| --- | --- |
| `storeUrl`, `storeDomain` | Store the product came from |
| `productId`, `handle`, `productUrl` | Product identifiers and storefront link |
| `title`, `vendor`, `productType`, `tags` | Catalog metadata |
| `price`, `minPrice`, `maxPrice` | Lowest variant price and the price range |
| `compareAtPrice`, `discountPercent` | Sale reference price and computed discount |
| `available`, `variantCount` | Any variant in stock; number of variants |
| `variants[]` | `id`, `title`, `sku`, `price`, `compareAtPrice`, `available`, `option1-3` |
| `images`, `featuredImage` | All product image URLs and the main image |
| `publishedAt`, `updatedAt` | Shopify timestamps (useful for spotting new or changed products) |
| `scrapedAt` | Scrape timestamp |

Prices are in the store's own currency as published in its product feed.

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

Pay per product saved:

| Products | Price |
| --- | --- |
| 100 | $0.30 |
| 1,000 | $3.00 |
| 10,000 | $30.00 |

Plus a negligible start event ($0.00005 per GB). Variants and images are included in the product price. Failed or blocked stores produce no product rows and are not charged. See the **Pricing** tab for current rates.

### How to scrape a Shopify store

1. Paste one or more store URLs into **Store URLs** (or bulk-paste into the text box).
2. Set **Max products per store** and **Max total products**.
3. Optional: turn on **Only available** or **Only discounted**, and turn off variants or images for a smaller export.
4. Click **Start** and export the dataset.

#### Input example

```json
{
  "storeUrls": ["https://allbirds.com", "https://www.deathwishcoffee.com"],
  "maxProductsPerStore": 500,
  "maxTotalProducts": 1000,
  "includeVariants": true,
  "includeImages": true
}
```

#### Input example: sale and discount discovery

```json
{
  "storeUrlsText": "allbirds.com\ngymshark.com\nkyliecosmetics.com",
  "onlyDiscounted": true,
  "onlyAvailable": true,
  "maxProductsPerStore": 1000,
  "maxTotalProducts": 3000
}
```

### Output example

```json
{
  "storeUrl": "https://allbirds.com",
  "storeDomain": "allbirds.com",
  "productId": 6993276256336,
  "title": "Men's Tree Runners",
  "handle": "mens-tree-runners",
  "vendor": "Allbirds",
  "productType": "Shoes",
  "tags": ["mens", "runners"],
  "price": 98,
  "compareAtPrice": null,
  "minPrice": 98,
  "maxPrice": 98,
  "discountPercent": null,
  "available": true,
  "variantCount": 12,
  "variants": [
    { "id": 40312345678928, "title": "8", "sku": "TR-M-8", "price": 98, "compareAtPrice": null, "available": true, "option1": "8", "option2": null, "option3": null }
  ],
  "images": ["https://cdn.shopify.com/s/files/1/example.png"],
  "featuredImage": "https://cdn.shopify.com/s/files/1/example.png",
  "productUrl": "https://allbirds.com/products/mens-tree-runners",
  "publishedAt": "2026-03-01T10:00:00-05:00",
  "updatedAt": "2026-10-20T08:15:00-04:00",
  "scrapedAt": "2026-10-25T07:42:40.000Z"
}
```

Illustrative record. Each run also saves `SUMMARY` (stores, products per store, failures) and `ERRORS`.

### Use cases

- **Competitor price tracking** - schedule a saved task daily and compare `price` and `compareAtPrice` per `productId` across runs in Sheets or your database.
- **Product feed export** - turn any Shopify catalog into a CSV for marketplaces, comparison sites, or a migration.
- **Sale monitoring** - find which competitors are discounting and by how much.
- **Assortment and merchandising research** - compare vendors, product types, tags, and variant depth between brands.
- **Dropshipping and sourcing** - list products, SKUs, and stock from supplier stores.

### Run the Shopify scraper via API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("sonic_scraper/shopify-product-price-monitor").call(run_input={
    "storeUrls": ["https://allbirds.com"],
    "maxProductsPerStore": 200,
})
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["title"], p["price"], p["discountPercent"])
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('sonic_scraper/shopify-product-price-monitor').call({
  storeUrls: ['https://www.deathwishcoffee.com'],
  onlyDiscounted: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length);
```

Connect to Google Sheets, Make, Zapier, n8n, Slack, or webhooks with Apify integrations, or call it from AI agents through the Apify MCP server.

### FAQ

#### Do I need a Shopify API key or store access?

No. The Actor reads the public product feed that most Shopify storefronts expose.

#### Does it work on every Shopify store?

Most stores work. Some stores disable or protect their public product feed, and non-Shopify sites have none; those stores are listed in `ERRORS` with the reason and are not charged.

#### Does it detect price changes between runs?

Each run is a full snapshot with stable `productId` and variant `id` values plus Shopify's `updatedAt`, so you can diff two runs in a spreadsheet or database. Built-in cross-run change detection is not included yet.

#### Does it return inventory quantities?

It returns per-variant availability (`available: true/false`), not exact stock counts.

#### Which currency are prices in?

The store's default currency as published in its feed.

#### Can I scrape a single collection?

Not yet; the Actor scrapes the whole store catalog. Filter by `productType` or `tags` after export.

### Related Actors

- [Amazon Product Scraper & Price Tracker](https://apify.com/sonic_scraper/amazon-product-intelligence) - prices, ratings, and price-change alerts on Amazon.
- [Facebook Ads Library Scraper](https://apify.com/sonic_scraper/meta-ads-library-scraper-no-login) - see which Shopify brands are advertising and what they promote.
- [B2B Website Intelligence Scraper](https://apify.com/sonic_scraper/b2b-website-intelligence-scraper) - tech stack and contacts for the stores you track.

# Actor input Schema

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

Shopify store homepages or product/catalog URLs. The Actor will use each store's public /products.json feed.

## `storeUrlsText` (type: `string`):

Paste one Shopify store URL per line or comma-separated.

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

Maximum products to scrape from each Shopify store.

## `maxTotalProducts` (type: `integer`):

Maximum products to output across the whole run. Default is 100 so test runs stay small.

## `includeVariants` (type: `boolean`):

Include all product variants in each output row.

## `includeImages` (type: `boolean`):

Include image URLs for each product.

## `onlyAvailable` (type: `boolean`):

Only output products with at least one available variant.

## `onlyDiscounted` (type: `boolean`):

Only output products where compare-at price is higher than current price.

## `dedupe` (type: `boolean`):

Remove duplicate product URLs across stores.

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

Delay between page requests to each Shopify store.

## `maxConcurrency` (type: `integer`):

Number of stores to scrape in parallel.

## `onlyChanges` (type: `boolean`):

Compare with the previous run that used the same state key and return only new products and products whose price, compare-at price, availability or variants changed. Each row gets changeType, previousPrice and priceChange. Unchanged products are not returned or billed. The first run returns every product as the baseline.

## `stateKey` (type: `string`):

Name for the saved price snapshot. Use a different key per monitored set of stores.

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

Optional proxy. Most Shopify product feeds work without a proxy.

## `debugMode` (type: `boolean`):

Verbose logging.

## Actor input object example

```json
{
  "storeUrls": [
    "https://allbirds.com",
    "https://www.deathwishcoffee.com"
  ],
  "maxProductsPerStore": 100,
  "maxTotalProducts": 100,
  "includeVariants": true,
  "includeImages": true,
  "onlyAvailable": false,
  "onlyDiscounted": false,
  "dedupe": true,
  "requestDelayMs": 300,
  "maxConcurrency": 3,
  "onlyChanges": false,
  "stateKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "debugMode": false
}
```

# Actor output Schema

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

One row per Shopify product.

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

Totals, store counts, and warnings.

## `errors` (type: `string`):

Stores that failed or were not public Shopify feeds.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "storeUrls": [
        "https://allbirds.com",
        "https://www.deathwishcoffee.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sonic_scraper/shopify-product-price-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "storeUrls": [
        "https://allbirds.com",
        "https://www.deathwishcoffee.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sonic_scraper/shopify-product-price-monitor").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "storeUrls": [
    "https://allbirds.com",
    "https://www.deathwishcoffee.com"
  ]
}' |
apify call sonic_scraper/shopify-product-price-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sonic_scraper/shopify-product-price-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/kefb0Xy5H4eBgtrdQ/builds/ImCFR2JD6H89aoxZC/openapi.json
