# 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
- **Features:** Limited permissions
- **Stats:** 1 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 & Stock 🛍️

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/shopify-store-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg?style=flat-square)](https://apify.com/haketa/shopify-store-scraper)
[![Output Format](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](https://apify.com/haketa/shopify-store-scraper)
[![E-Commerce Intelligence](https://img.shields.io/badge/E--Commerce-Price%20%26%20Variant%20Tracking-purple?style=flat-square)](https://apify.com/haketa/shopify-store-scraper)
[![Multi-Store](https://img.shields.io/badge/Multi--Store-Full%20Catalog%20Extraction-brightgreen?style=flat-square)](https://apify.com/haketa/shopify-store-scraper)

**Extract complete product catalogs, variant pricing, stock availability, and high-resolution media from any Shopify store at scale — no coding, no login, and no browser overhead.** This enterprise-grade **Shopify store scraper** extracts structured e-commerce intelligence across any Shopify storefront: **product title, URL handle, brand vendor, product categorization, searchable tags, plain-text description, price min/max ranges, compare-at retail prices, on-sale discount flags, store currency, stock availability status, options (size, color, material), per-variant SKUs, and complete photo galleries.**

Export structured product feeds directly to **JSON, CSV, Excel, XML, or ingest programmatically via the Apify REST API and SDKs.**

> Built for **dropshippers, e-commerce retailers, price monitoring teams, competitive intelligence analysts, catalog aggregators, and digital agency developers.**

***

### ⚡ At a glance

| Feature | Specification |
|:---|:---|
| **Platform Compatibility** | Any public Shopify or Shopify Plus storefront globally |
| **Extraction Modes** | Full catalog sweep, collection handle filtering, or targeted product search |
| **Output Formats** | JSON, CSV, XLSX, XML, RSS, HTML Table |
| **Pagination Volume** | Unlimited 1,000+ deep pagination (250 products per batch) |
| **Variant Granularity** | Full variant array: SKU, variant price, compare-at price, available flag, options, weight |
| **Pricing Intelligence** | `priceMin`, `priceMax`, `compareAtPriceMax`, `onSale`, localized `currency` |
| **Media Extraction** | Main featured image URL, full multi-image array, total image count |
| **Multi-Store Support** | Scrape multiple store domains in a single consolidated run |
| **Execution Speed** | ~100–250 products per second |
| **Default Proxy** | Datacenter Apify Proxy (fully supported out of the box) |

***

### 🔎 Why scrape Shopify storefronts?

Shopify powers millions of leading direct-to-consumer (DTC) brands and retail enterprises across the globe. From boutique apparel creators to multi-million-dollar footwear giants, these storefronts represent real-time consumer demand, retail pricing strategies, promotional schedules, and inventory velocity.

For digital commerce businesses, staying ahead requires live catalog monitoring:

1. **Dynamic Price Intelligence**: Track competitor price drops, seasonal flash sales, and discount depth (`compareAtPriceMax` vs `priceMin`).
2. **Dropshipping & Catalog Feeds**: Export verified product titles, structured variants (sizes, colors), and product descriptions ready for immediate re-import into Shopify, WooCommerce, or BigCommerce stores.
3. **Inventory & Stock Monitoring**: Monitor which SKUs are actively selling out or restocking in real time via the `available` and `inStock` flags.
4. **Assortment Gap Analysis**: Discover newly published product lines, expanding color palettes, and popular vendor brands across your competitive landscape.

Attempting to scrape Shopify catalogs with heavy headless browsers is notoriously slow, fragile, and expensive. This **Shopify product scraper** operates with streamlined HTTP requests, ensuring rapid, lightweight, and cost-effective extraction across thousands of items.

***

### 🚀 Key features & capabilities

- 🌐 **Any Shopify Store**: Accepts any storefront URL or domain (e.g. `https://www.allbirds.com`, `gymshark.com`, `kith.com`) and automatically detects store currency and catalog endpoints.
- 🎯 **Three Flexible Extraction Modes**:
  - **Full Catalog**: Automatically paginates through the entire product catalog (250 items per page) to harvest the whole store.
  - **Collection Filter**: Target specific collections by handle (e.g., `mens-shoes`, `summer-sale`, `new-arrivals`).
  - **Product Search**: Query specific keywords across the store's search system to isolate targeted product lines.
- 📊 **Multi-Variant Breakdown**: Extracts detailed nested arrays for every product variant: unique variant ID, SKU, exact price, compare-at price, availability, grams weight, and options (Option 1, 2, 3).
- 🏷️ **Price & Discount Analytics**: Surfaces calculated fields including lowest price, highest price, highest compare-at price, and a boolean `onSale` indicator.
- 🖼️ **High-Resolution Galleries**: Collects high-res product imagery arrays for seamless media syndication and catalog migration.
- 🏬 **Multi-Store Processing**: Provide multiple store URLs in a single run; the actor processes each store sequentially, tagging records with `storeDomain` and localized `storeCountry` and `currency`.
- 🔄 **Unlocked 1,000+ Deep Pagination**: Smoothly pages through deep inventories without arbitrary caps, governed only by your specified `maxItems` or `maxProductsPerStore`.

***

### 📊 Extracted fields & data dictionary

#### 📦 Product Master Data

| Field | Type | Description | Coverage |
|:---|:---|:---|:---:|
| `productId` | Integer | Unique Shopify product identifier | 🟢 High (100%) |
| `title` | String | Product commercial title | 🟢 High (100%) |
| `handle` | String | URL slug handle for canonical page resolution | 🟢 High (100%) |
| `url` | String | Direct link to the live product detail page | 🟢 High (100%) |
| `vendor` | String | Brand or manufacturer name | 🟢 High (98%) |
| `productType` | String | Category or product type assigned by merchant | 🟢 High (95%) |
| `tags` | Array\[String] | Merchant tags for categorization and search | 🟢 High (95%) |
| `description` | String | Clean plain-text product description (HTML stripped) | 🟢 High (98%) |

#### 💰 Pricing & Inventory Status

| Field | Type | Description | Coverage |
|:---|:---|:---|:---:|
| `priceMin` | Float | Lowest variant price available | 🟢 High (100%) |
| `priceMax` | Float | Highest variant price available | 🟢 High (100%) |
| `compareAtPriceMax` | Float | Highest original non-discounted compare-at price | 🟡 Conditional (Sale items) |
| `onSale` | Boolean | True if any variant price is discounted below compare-at | 🟢 High (100%) |
| `currency` | String | Three-letter ISO currency code (e.g. `USD`, `EUR`, `GBP`) | 🟢 High (100%) |
| `inStock` | Boolean | True if at least one variant is available for purchase | 🟢 High (100%) |
| `variantsCount` | Integer | Total number of variants for this product | 🟢 High (100%) |

#### 🛠️ Variants, Options & Media

| Field | Type | Description | Coverage |
|:---|:---|:---|:---:|
| `variants` | Array\[Object] | Full variant array (ID, SKU, price, compare-at, available, weight) | 🟢 High (100% when enabled) |
| `options` | Array\[Object] | Configured product options and value sets (e.g. Size, Color) | 🟢 High (100%) |
| `featuredImage` | String | Primary hero image URL | 🟢 High (98%) |
| `images` | Array\[String] | Array of all gallery photo URLs | 🟢 High (98%) |
| `imagesCount` | Integer | Number of images attached to product | 🟢 High (100%) |
| `publishedAt` | String | Timestamp when product was made visible | 🟢 High (100%) |
| `storeName` | String | Official registered name of the Shopify merchant | 🟢 High (95%) |
| `storeDomain` | String | Store hostname (e.g. `www.allbirds.com`) | 🟢 High (100%) |
| `scrapedAt` | String | ISO 8601 data extraction timestamp | 🟢 High (100%) |

***

### 💻 Sample output (JSON)

```json
{
  "productId": 7891234567890,
  "title": "Men's Wool Runner 2",
  "handle": "mens-wool-runner-2",
  "url": "https://www.allbirds.com/products/mens-wool-runner-2",
  "vendor": "Allbirds",
  "productType": "Men's Shoes",
  "tags": ["wool", "runners", "sustainable", "classic", "sale"],
  "description": "Our iconic everyday sneaker made with soft ZQ Merino wool, featuring upgraded cushioning and enhanced durability.",
  "priceMin": 89.0,
  "priceMax": 110.0,
  "compareAtPriceMax": 110.0,
  "onSale": true,
  "currency": "USD",
  "inStock": true,
  "variantsCount": 6,
  "options": [
    { "name": "Size", "values": ["8", "9", "10", "11", "12", "13"] },
    { "name": "Color", "values": ["Natural Black", "Dapple Grey"] }
  ],
  "variants": [
    {
      "variantId": 41234567890123,
      "title": "Natural Black / 10",
      "sku": "WR2-BLK-10",
      "price": 89.0,
      "compareAtPrice": 110.0,
      "available": true,
      "option1": "Natural Black",
      "option2": "10",
      "grams": 650,
      "requiresShipping": true,
      "taxable": true
    }
  ],
  "featuredImage": "https://cdn.shopify.com/s/files/1/1104/4168/products/wool_runner_hero.jpg",
  "images": [
    "https://cdn.shopify.com/s/files/1/1104/4168/products/wool_runner_hero.jpg",
    "https://cdn.shopify.com/s/files/1/1104/4168/products/wool_runner_side.jpg"
  ],
  "imagesCount": 2,
  "publishedAt": "2024-03-15T08:00:00-07:00",
  "createdAt": "2024-02-10T11:20:00-08:00",
  "updatedAt": "2026-11-08T16:45:00-08:00",
  "storeName": "Allbirds",
  "storeDomain": "www.allbirds.com",
  "storeCountry": "United States",
  "scrapedAt": "2026-11-10T14:45:00.000Z"
}
```

***

### 🎯 High-impact use cases

#### 1. Competitive Price Monitoring & MAP Enforcement

Track competitor pricing across dozens of rival Shopify stores. Schedule daily automated runs to detect when competitors discount products, change compare-at retail prices, or launch flash sales.

#### 2. Dropshipping Catalog Sourcing & Migration

Export entire niche store catalogs with structured variants, SKU identifiers, descriptions, and CDN image URLs. Import the generated CSV directly into your own store, saving weeks of manual listing creation.

#### 3. Inventory Stock Alerts & Restock Tracking

Identify which product variants are selling out and monitor when out-of-stock items become available again. Monitor supplier stock movements before placing bulk inventory orders.

#### 4. Market Trend & Assortment Benchmarking

Analyze which product categories, colorways, and price brackets dominant brands in your industry focus on. Compare average product counts and pricing distributions across multiple direct-to-consumer competitors.

#### 5. AI Catalog Enrichment & Visual Search

Ingest complete product photo galleries and structured descriptions into vector databases for visual search applications, AI recommendation engines, and automated merchandising systems.

***

### ⚙️ Input configuration

| Field | Type | Default | Description |
|:---|:---|:---:|:---|
| `storeUrls` | Array\[String] | `["https://www.allbirds.com"]` | Shopify store URLs or domains to scrape. |
| `searchTerms` | Array\[String] | `[]` | Optional keywords to search specific products within stores. |
| `collections` | Array\[String] | `[]` | Optional collection handles (e.g. `mens-shoes`) to restrict extraction. |
| `includeVariants` | Boolean | `true` | Include detailed variant array (SKU, variant price, stock). |
| `maxItems` | Integer | `0` | Total maximum products across all stores. `0` = unlimited. |
| `maxProductsPerStore` | Integer | `0` | Maximum products per store. `0` = unlimited (governed by `maxItems`). |
| `proxyConfiguration` | Object | Datacenter | Apify Proxy configuration. Datacenter proxy works reliably out of the box. |

***

### 🛠️ Code examples

#### Python (apify-client)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv("APIFY_TOKEN"))

run_input = {
    "storeUrls": ["https://www.allbirds.com"],
    "collections": ["mens-shoes"],
    "includeVariants": True,
    "maxItems": 150,
}

run = client.actor("haketa/shopify-store-scraper").call(run_input=run_input)
products = client.dataset(run["defaultDatasetId"]).list_items().items

for p in products:
    print(f"[{p.get('currency')} {p.get('priceMin')}] {p.get('title')} (Variants: {p.get('variantsCount')})")
```

#### Node.js (apify-client)

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

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
});

const run = await client.actor('haketa/shopify-store-scraper').call({
    storeUrls: ['https://www.allbirds.com'],
    maxItems: 250,
    maxProductsPerStore: 0,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Successfully extracted ${items.length} Shopify products!`);
```

***

### 💡 Practical tips for optimal runs

- **Extracting Specific Categories**: If a store has 20,000+ items and you only need footwear, find the collection URL (e.g. `/collections/footwear`) and pass `collections: ["footwear"]`.
- **Handling Multi-Currency Stores**: When scraping regional storefronts (e.g. `.com` vs `.ca` vs `.co.uk`), pass each store URL separately; the scraper automatically captures each domain's distinct currency.
- **Lightweight Export**: If you only need price trends and master product titles, you can set `includeVariants: false` to dramatically reduce dataset file sizes.
- **Protected Stores**: A tiny minority of enterprise brands place custom firewall gates in front of their product feeds; the actor automatically detects these and gracefully skips them without interrupting the remaining crawl.

***

### ❓ Frequently asked questions (FAQ)

##### How do I know if a website is powered by Shopify?

Most Shopify stores include `/products` in their URLs, feature Shopify CDN links (`cdn.shopify.com`), or include `Shopify.theme` in page source code. You can simply paste any store domain into `storeUrls` — the actor validates the platform automatically.

##### How many products can I scrape from a store?

You can scrape the entire store catalog. With `maxProductsPerStore: 0` and `maxItems: 0`, the scraper paginates through all available product batches (250 items per page) until the full inventory is extracted.

##### Can I scrape multiple stores at the same time?

Yes. You can supply an array of store domains in `storeUrls` (e.g., `["https://store-a.com", "https://store-b.com"]`). The actor crawls each store sequentially, tagging each record with `storeDomain` and localized currency.

##### Does this scraper extract variant SKUs and barcodes?

Yes. When `includeVariants` is enabled (default), every variant object contains its assigned `sku`, unique `variantId`, `price`, `compareAtPrice`, and weight in `grams`.

##### What formats can I download the catalog data in?

From the Apify Console, you can download your scraped product data in CSV, Microsoft Excel (XLSX), JSON, XML, or HTML format with a single click.

##### Can I import the output CSV directly into another Shopify store?

Yes. The output fields closely match standard e-commerce schemas. With minor column renaming, you can import products and variants directly into Shopify, WooCommerce, or BigCommerce.

##### Does this scraper require a Shopify Partner account or API token?

No. The scraper queries public storefront catalog feeds without requiring API credentials, private app tokens, or merchant admin permissions.

##### How frequently should I monitor competitor prices?

Most e-commerce teams configure Apify Schedules to run the actor daily or weekly to capture promotional discounts and catalog updates.

##### Does the scraper work with Apify Proxy?

Yes. Apify Datacenter Proxy is supported and enabled by default, ensuring fast throughput and reliable connectivity.

##### Does it capture product reviews?

No. Product reviews are typically hosted by third-party apps (e.g., Yotpo, Judge.me, Okendo) rather than core Shopify catalog feeds. This actor focuses strictly on products, variants, pricing, options, and stock.

***

### 🔄 Integrations & automated workflows

#### Automated Price Drop Alerts (Slack / Email)

1. Schedule a daily scraping run of competitor store URLs.
2. Connect Apify to Make or Zapier with a filter for `onSale == true`.
3. Post automated notifications to your e-commerce merchandising channel whenever a competitor launches a discount.

#### Automated Inventory Feeds (Google Sheets / Airtable)

1. Use the Apify Google Sheets integration to stream scraped products into a master inventory sheet.
2. Map `title`, `priceMin`, `compareAtPriceMax`, `inStock`, and `url`.
3. Maintain an always-fresh competitor benchmark dashboard for your marketing team.

***

### 📈 Performance & scalability benchmarks

| Catalog Size | Extraction Mode | Approx. Execution Time | Memory Required | Est. Cost Profile |
|:---:|:---:|:---:|:---:|:---:|
| **100 products** | Catalog / Collection | ~4–8 seconds | 512 MB | ~$0.001 |
| **500 products** | Full Catalog | ~15–30 seconds | 512 MB | ~$0.005 |
| **1,000 products** | Full Catalog | ~30–60 seconds | 512 MB | ~$0.010 |
| **5,000+ products** | Multi-Store Sweep | ~2–4 minutes | 1024 MB | ~$0.035 |

***

### 🔗 Related scrapers

- [Welcome to the Jungle Company Scraper](https://apify.com/haketa/wttj-companies-scraper) — Firmographics, tech stack & hiring signals.
- [Eventbrite Scraper](https://apify.com/haketa/eventbrite-scraper) — Extract business events and organizer leads.
- [Czech Company Registry Scraper for ARES](https://apify.com/haketa/czech-ares-scraper) — Official Czech business entity verification.
- [We Work Remotely Scraper](https://apify.com/haketa/weworkremotely-scraper) — Remote job postings and hiring company contacts.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Deep Pagination & Unlimited Extraction**: Standardized `maxProductsPerStore` and `maxItems` to default `0` (unlimited, governed only by total products).
- **Graceful Empty Run Handling**: Added fallback default store (`https://www.allbirds.com`), guaranteeing empty inputs return ~100 sample records.
- **Fast Prefill Optimization**: Reduced prefill run duration to under 15 seconds for rapid testing.
- **Variant Processing Refinements**: Enhanced price parsing, floating-point normalization, and compare-at discount calculations.
- **Multi-Currency Normalization**: Enhanced currency resolution logic to capture local currency across multi-region storefronts.

#### v1.1

- Added collection handle filtering (`collections`).
- Added product search query mode (`searchTerms`).
- Added multi-store sequential processing.

#### v1.0

- Initial release featuring Shopify catalog extraction, variant pricing, options parsing, and JSON/CSV export.

***

### 🛍️ Dropshipping & catalog re-import guide

One of the most popular applications of the Shopify Store Scraper is exporting a product catalog for seamless import into a new e-commerce store. Follow these practical steps:

#### Exporting & Mapping Columns

1. Execute the actor targeting your desired store URL and download the resulting dataset as **CSV**.
2. If importing directly into another **Shopify** store, map the following standard columns:
   - `handle` ➔ **Handle** (unique product URL handle)
   - `title` ➔ **Title** (product commercial name)
   - `description` ➔ **Body (HTML)** (plain-text or formatted description)
   - `vendor` ➔ **Vendor** (brand or supplier name)
   - `productType` ➔ **Type** (product categorization)
   - `tags` ➔ **Tags** (search and collection tags)
   - `priceMin` ➔ **Variant Price**
   - `compareAtPriceMax` ➔ **Variant Compare At Price**
   - `featuredImage` ➔ **Image Src**
3. Open your Shopify Admin dashboard, navigate to **Products ➔ Import**, upload your mapped CSV, and click **Upload and preview**.

#### Multi-Variant Product Structuring

When `includeVariants` is active, products with multiple sizes, colors, or materials include their full variant matrix. You can expand the `variants` array into individual rows in Excel or Google Sheets to maintain exact SKU barcodes, custom prices per size, and specific weight configurations for accurate shipping calculation.

***

### 📊 Price intelligence & promotional discount tracking

E-commerce pricing analysts use the actor's calculated price fields to detect marketing promotions:

- **`onSale`**: Evaluated as `true` whenever `compareAtPriceMax` exceeds `priceMin`. This immediately flags discounted merchandise.
- **Discount Depth Calculation**: Calculate percentage markdown dynamically: `Discount % = ((compareAtPriceMax - priceMin) / compareAtPriceMax) * 100`.
- **Price Range Variance**: When `priceMin != priceMax`, the product has tiered variant pricing (e.g., larger sizes or premium materials carry a price surcharge).
- **Clearance Inventory Detection**: Combine `onSale: true` with specific variant `available: false` flags to identify products being cleared out prior to seasonal phase-out.

***

### 🔒 Responsible scraping & trademark notice

This actor extracts purely publicly accessible product catalogs from online storefronts. This tool is an independent utility and is not officially affiliated with, endorsed by, or sponsored by Shopify Inc.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/shopify-store-scraper/changelog.md

# 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). 0 = unlimited governed by Max products.

## `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": 100,
  "maxProductsPerStore": 0,
  "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": 100,
    "maxProductsPerStore": 0,
    "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": 100,
    "maxProductsPerStore": 0,
    "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": 100,
  "maxProductsPerStore": 0,
  "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/hVl7eqZTVfoXPCkfj/openapi.json