# Shopify Store Product Scraper — Products, Variants & Prices (`haketa/shopify-store-scraper`) Actor

Scrape products from any Shopify store: title, description, vendor, type, tags, all variants (SKU, price, compare-at, stock), images, options and store currency. Search, by collection, or full catalog. For price tracking, dropshipping and competitor research. Not affiliated with Shopify.

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

## Pricing

from $1.75 / 1,000 results

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

> **Scrape every product from any Shopify store: title, description, vendor, type, tags, all variants (SKU, price, compare-at price, stock), images, options and the store's currency.** Pull the full catalog, a single collection, or search for specific products — across one store or many. Clean JSON/CSV/Excel in seconds. Built for price tracking, dropshipping, competitor and catalog research.

[![Shopify](https://img.shields.io/badge/Shopify-Any%20Store-96bf48)]()
[![Variants + Prices](https://img.shields.io/badge/Variants%20%2B%20Prices-2da44e)]()
[![Price Tracking](https://img.shields.io/badge/Price%20Tracking%20%2F%20Dropshipping-8250df)]()
[![Export](https://img.shields.io/badge/Export-JSON%20%2F%20CSV%20%2F%20Excel-fb8500)]()

***

### What This Actor Does

Give it one or more Shopify store URLs and it returns every product as a clean record:

- **Product** — title, handle, URL, vendor/brand, product type, tags, plain-text description
- **Pricing** — min/max price, compare-at price, **on-sale** flag, and the store's **currency**
- **Variants** — every variant with title, SKU, price, compare-at price, options and **stock status**
- **Options** — size/color/etc. option sets
- **Media** — featured image and all image URLs
- **Dates** — published, created and updated timestamps
- **Store** — store name, domain and country

Three ways to pull products:

1. **Full catalog** — every product in the store (default).
2. **By collection** — only the collection handles you specify.
3. **By search** — find specific products by keyword within each store.

Works across **multiple stores in one run**, each with its own currency.

***

### Why Use This

- **Track competitor prices & stock.** Snapshot any store's catalog with prices, compare-at prices and stock on a schedule.
- **Power dropshipping & reselling.** Export full catalogs with variants, SKUs and images ready to import.
- **Research products & assortments.** Analyse pricing, product types, vendors and sale depth across stores.
- **Clean and fast.** Reads each store's public product data — no key, no login, no browser.

***

### Quick Start

#### Run it in the console (no code)

1. Paste one or more **Shopify store URLs** (e.g. `https://www.allbirds.com`).
2. Optionally add **collection handles** or **product searches** to narrow it down.
3. Set **Max products**, click **Start**, and export as **JSON, CSV, Excel or HTML**.

#### Track prices across stores (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "storeUrls": ["https://www.allbirds.com", "https://www.allbirds.ca"],
    "maxItems": 5000,
}

run = client.actor("YOUR_USERNAME/shopify-store-scraper").call(run_input=run_input)

for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["title"], "·", p["priceMin"], p["currency"], "· on sale:", p["onSale"], "· in stock:", p["inStock"])
```

#### Scrape one collection (Python)

```python
run = client.actor("YOUR_USERNAME/shopify-store-scraper").call(run_input={
    "storeUrls": ["https://www.allbirds.com"],
    "collections": ["mens-shoes"],
})
```

***

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `storeUrls` | array | Shopify store URLs or domains. Accepts domains, home pages or any store URL. |
| `searchTerms` | array | Search for specific products within each store (optional). |
| `collections` | array | Only scrape these collection handles (optional). |
| `includeVariants` | boolean | Include the full per-variant array (default on). |
| `maxItems` | integer | Max products across all stores. `0` = no limit. |
| `maxProductsPerStore` | integer | Cap products per store. |
| `proxyConfiguration` | object | Apify Proxy. Datacenter is enough (public store JSON). |

***

### Output

Each product is one record:

```json
{
  "productId": 123456789,
  "title": "Men's Tree Runner - Jet Black",
  "handle": "mens-tree-runner-jet-black",
  "url": "https://www.allbirds.com/products/mens-tree-runner-jet-black",
  "vendor": "Allbirds", "productType": "Shoes",
  "tags": ["tree", "everyday"],
  "priceMin": 100, "priceMax": 100, "compareAtPriceMax": 120,
  "onSale": true, "currency": "USD", "inStock": true,
  "variantsCount": 7,
  "variants": [
    {"variantId": 111, "title": "8", "sku": "TR-JB-8", "price": 100, "compareAtPrice": 120, "available": true, "option1": "8"}
  ],
  "options": [{"name": "Size", "values": ["8", "9", "10"]}],
  "featuredImage": "https://cdn.shopify.com/...jpg",
  "images": ["https://cdn.shopify.com/...jpg"],
  "storeName": "Allbirds", "storeDomain": "www.allbirds.com", "storeCountry": "US"
}
```

***

### Use Cases

#### 1. Competitor price & stock monitoring

Snapshot any store's prices, compare-at prices and stock on a schedule and track changes over time.

#### 2. Dropshipping & product sourcing

Export full catalogs with variants, SKUs, options and images, ready to import into your own store.

#### 3. Market & assortment research

Compare pricing, product types, vendors and sale depth across multiple stores and regions.

#### 4. Catalog backup & sync

Keep a structured copy of a store's catalog for analytics, feeds or price comparison.

***

### Tips

- **Multiple stores, multiple currencies** — each store's currency is read from its own store metadata.
- **`onSale`** combines compare-at and current price so you can filter discounts instantly.
- **`collections`** narrows big catalogs to just the category you care about.
- **`searchTerms`** is the fastest way to pull a few specific products from a large store.
- **Schedule it** with Apify Schedules for daily price/stock snapshots.

***

### Frequently Asked Questions

**Do I need an account or key?**
No. Shopify stores expose public product data — no login, key or anti-bot.

**Does it work on every Shopify store?**
It works on standard Shopify storefronts. A small number of stores sit behind an extra bot-protection layer that can block automated access; those are skipped with a warning.

**Can I get stock / inventory?**
Yes — each variant has an `available` flag, and each product has an `inStock` summary.

**How is price returned?**
As a number in the store's own currency (included as `currency`). Both current and compare-at prices are provided.

**What export formats are supported?**
JSON, CSV, Excel, HTML, or via API — plus Google Sheets, webhooks, Make and Zapier.

***

### Legal & Responsible Use

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Shopify Inc.** All trademarks are the property of their respective owners. It reads only public product data. Use the data responsibly and in line with applicable terms and laws.

# Actor input Schema

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

Shopify store URLs or domains (e.g. https://www.allbirds.com). Accepts domains, home pages or any store URL.

## `searchTerms` (type: `array`):

Search terms to find specific products within each store. Leave empty to get the full catalog (or use collections).

## `collections` (type: `array`):

Only scrape these collection handles (e.g. mens-shoes). Leave empty for the full catalog.

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

Include the full per-variant array (SKU, price, options, stock). Price range is always included.

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

Maximum products across all stores. 0 = no limit.

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

Cap products per store (250 per page).

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

Apify Proxy. Store JSON is public — datacenter is enough and enabled by default.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.allbirds.com"
  ],
  "includeVariants": true,
  "maxItems": 200,
  "maxProductsPerStore": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `productId` (type: `string`):

Shopify product ID

## `title` (type: `string`):

Product title

## `handle` (type: `string`):

URL handle

## `url` (type: `string`):

Product URL

## `vendor` (type: `string`):

Vendor/brand

## `productType` (type: `string`):

Product type

## `tags` (type: `string`):

Tags

## `description` (type: `string`):

Plain-text description

## `priceMin` (type: `string`):

Lowest variant price

## `priceMax` (type: `string`):

Highest variant price

## `compareAtPriceMax` (type: `string`):

Highest compare-at

## `onSale` (type: `string`):

On sale

## `currency` (type: `string`):

Store currency

## `inStock` (type: `string`):

Any variant in stock

## `variantsCount` (type: `string`):

Number of variants

## `variants` (type: `string`):

Per-variant details

## `options` (type: `string`):

Product options

## `featuredImage` (type: `string`):

Main image URL

## `images` (type: `string`):

All image URLs

## `publishedAt` (type: `string`):

Publish date

## `updatedAt` (type: `string`):

Last update

## `storeName` (type: `string`):

Store name

## `storeDomain` (type: `string`):

Store domain

## `storeCountry` (type: `string`):

Store country

## `scrapedAt` (type: `string`):

ISO timestamp

# 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://www.allbirds.com"
    ],
    "maxItems": 200,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/shopify-store-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 = {
    "storeUrls": ["https://www.allbirds.com"],
    "maxItems": 200,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/shopify-store-scraper").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://www.allbirds.com"
  ],
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/shopify-store-scraper --silent --output-dataset

```

## MCP server setup

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

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/F7KJycTR6TV0bGuOs/builds/VcHzPPNs0rf1tk11d/openapi.json