# Shopify Store Scraper - Products & Collections Extractor (`xquantify/shopify-store-scraper`) Actor

Extract products, collections & inventory from any Shopify store. Multi-currency support, stock detection, anti-bot bypass. Fast, reliable & easy to use.

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

## Pricing

$9.90 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Shopify Store Scraper - Products & Collections Extractor

Extract comprehensive product data, collections, and inventory information from any Shopify store. This powerful Apify Actor supports multi-currency pricing, stock status detection, and advanced anti-bot protection bypass.

### 🎉 FREE Tier: 500 Products/Month - No Credit Card Required!

**Pay-Per-Event Pricing:**

- ✅ **500 FREE products** every month
- ✅ **50 FREE collections** every month
- ✅ **$0 monthly rental fee**
- 💰 After free tier: Just $2 per 1,000 products
- 📊 Scale from free to enterprise seamlessly

[See full pricing details →](./PRICING.md)

### Features

#### Core Capabilities

- **Extract All Products**: Scrape complete product catalogs from any Shopify store
- **Collection Scraping**: Fetch all collections with product counts and metadata
- **Single Product Mode**: Extract detailed data from specific product URLs
- **Multi-Currency Support**: Get prices in any currency (USD, EUR, GBP, etc.)
- **Stock Status Detection**: Automatically detect InStock/OutOfStock status for products
- **Variant Support**: Extract all product variants with individual pricing and inventory
- **Image Extraction**: Get all product images in high resolution
- **Anti-Bot Protection**: Advanced techniques to bypass Shopify's gateway restrictions

#### Advanced Features

- **Currency Passthrough**: Automatic currency conversion using Shopify's API
- **Inventory Tracking**: Real-time stock quantities for each variant
- **Pagination Handling**: Automatically handles stores with thousands of products
- **Rate Limiting**: Smart delays and retry logic to avoid blocks
- **Residential Proxies**: Built-in proxy support for restricted stores
- **Comprehensive Data**: Extract titles, descriptions, prices, SKUs, tags, vendors, and more

### Use Cases

- **Price Monitoring**: Track competitor pricing across multiple Shopify stores
- **Market Research**: Analyze product trends and inventory levels
- **Dropshipping**: Find trending products and monitor stock availability
- **Product Database**: Build comprehensive product catalogs
- **Inventory Management**: Monitor stock levels across multiple stores
- **E-commerce Analytics**: Gather data for business intelligence

### Input Configuration

#### Basic Setup

```json
{
  "startUrls": [
    { "url": "https://example.myshopify.com/" }
  ],
  "mode": "PRODUCTS",
  "currency": "USD",
  "checkStock": true
}
```

#### Input Parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `startUrls` | Array | Yes | List of Shopify store URLs to scrape |
| `mode` | String | Yes | Scraping mode: `PRODUCTS`, `COLLECTIONS`, `SINGLE_PRODUCT`, or `ALL` |
| `currency` | String | No | ISO currency code (e.g., USD, EUR, GBP) |
| `collectionUrls` | Array | No | Specific collection URLs to scrape products from |
| `productUrls` | Array | No | Specific product URLs (for SINGLE\_PRODUCT mode) |
| `maxProducts` | Integer | No | Maximum number of products to scrape |
| `maxCollections` | Integer | No | Maximum number of collections to scrape |
| `includeVariants` | Boolean | No | Include all product variants (default: true) |
| `includeImages` | Boolean | No | Include product images (default: true) |
| `includeDescription` | Boolean | No | Include full descriptions (default: true) |
| `includeCategories` | Boolean | No | Include categories/collections each product belongs to (default: false) |
| `checkStock` | Boolean | No | Check stock status (default: true) |
| `proxyConfiguration` | Object | No | Proxy settings (recommended: residential proxies) |

### Scraping Modes

#### 1. All Products Mode (`PRODUCTS`)

Extracts all products from the store or specific collections.

```json
{
  "startUrls": [{ "url": "https://store.myshopify.com/" }],
  "mode": "PRODUCTS",
  "currency": "USD"
}
```

#### 2. Collections Mode (`COLLECTIONS`)

Extracts only collection information without products.

```json
{
  "startUrls": [{ "url": "https://store.myshopify.com/" }],
  "mode": "COLLECTIONS"
}
```

#### 3. Single Product Mode (`SINGLE_PRODUCT`)

Extracts detailed data for specific products.

```json
{
  "startUrls": [{ "url": "https://store.myshopify.com/" }],
  "mode": "SINGLE_PRODUCT",
  "productUrls": [
    "https://store.myshopify.com/products/awesome-product"
  ],
  "checkStock": true
}
```

#### 4. Everything Mode (`ALL`)

Extracts both collections and all products.

```json
{
  "startUrls": [{ "url": "https://store.myshopify.com/" }],
  "mode": "ALL",
  "currency": "EUR"
}
```

### Output Format

#### Product Data - Complete Field List

All products include the following fields:

**Basic Information:**

- `type`: "product"
- `id`: Unique product ID
- `title`: Product title/name
- `handle`: URL-friendly product handle
- `url`: Full product URL
- `vendor`: Brand/vendor name
- `productType`: Product type/category
- `tags`: Array of product tags
- `createdAt`: Product creation date
- `publishedAt`: Product publish date
- `updatedAt`: Last update date

**Pricing:**

- `price`: Minimum variant price
- `priceMax`: Maximum variant price (if different)
- `compareAtPrice`: Minimum compare-at price (original price)
- `compareAtPriceMax`: Maximum compare-at price (if different)
- `currency`: ISO currency code (USD, EUR, GBP, etc.)
- `onSale`: Boolean indicating if product is on sale

**Availability & Stock:**

- `stockStatus`: "InStock" or "OutOfStock"
- `availableForSale`: Boolean availability flag
- `totalInventory`: Total inventory count (if checkStock enabled)
- `availableVariants`: Number of available variants
- `totalVariants`: Total number of variants

**Taxability:**

- `taxable`: Boolean indicating if any variant is taxable
- `allVariantsTaxable`: Boolean indicating if all variants are taxable
- `taxCodes`: Array of unique tax codes (if available)

**SKUs:**

- `skus`: Array of all unique SKUs across variants

**Categories:**

- `categories`: Array of collections/categories this product belongs to (if includeCategories enabled)
- `categoriesCount`: Number of categories

**Images:**

- `images`: Array of all product images with metadata
- `featuredImage`: URL of the main product image
- `imagesCount`: Total number of images

**Variants:** (if includeVariants enabled)

- `variants`: Array of all product variants
- `variantsCount`: Total number of variants

**Options:**

- `options`: Product option configurations (Size, Color, etc.)

**Description:**

- `description`: Plain text description (if includeDescription enabled)
- `descriptionHtml`: HTML formatted description (if includeDescription enabled)

#### Example Product Output

```json
{
  "type": "product",
  "id": 1234567890,
  "title": "Amazing Product",
  "handle": "amazing-product",
  "url": "https://store.myshopify.com/products/amazing-product",
  "vendor": "Brand Name",
  "productType": "Electronics",
  "tags": ["new", "featured", "sale"],
  "createdAt": "2024-01-15T10:30:00Z",
  "publishedAt": "2024-01-16T08:00:00Z",
  "updatedAt": "2024-03-20T15:45:00Z",
  "price": "99.99",
  "priceMax": "149.99",
  "compareAtPrice": "129.99",
  "compareAtPriceMax": "159.99",
  "currency": "USD",
  "onSale": true,
  "stockStatus": "InStock",
  "availableForSale": true,
  "totalInventory": 150,
  "availableVariants": 3,
  "totalVariants": 6,
  "taxable": true,
  "allVariantsTaxable": true,
  "skus": ["ABC-001", "ABC-002", "ABC-003"],
  "description": "Full product description...",
  "descriptionHtml": "<p>Full product description...</p>",
  "featuredImage": "https://cdn.shopify.com/...",
  "imagesCount": 5,
  "images": [
    {
      "id": 12345,
      "src": "https://cdn.shopify.com/...",
      "alt": "Product image",
      "width": 2048,
      "height": 2048
    }
  ],
  "variantsCount": 6,
  "variants": [
    {
      "id": 98765,
      "title": "Small / Black",
      "sku": "ABC-001",
      "barcode": "123456789012",
      "price": "99.99",
      "compareAtPrice": "129.99",
      "available": true,
      "inventoryQuantity": 45,
      "inventoryManagement": "shopify",
      "inventoryPolicy": "deny",
      "taxable": true,
      "taxCode": null,
      "option1": "Small",
      "option2": "Black",
      "option3": null,
      "weight": 500,
      "weightUnit": "g",
      "requiresShipping": true,
      "fulfillmentService": "manual"
    }
  ],
  "options": [
    {
      "name": "Size",
      "position": 1,
      "values": ["Small", "Medium", "Large"]
    },
    {
      "name": "Color",
      "position": 2,
      "values": ["Black", "White", "Red"]
    }
  ],
  "categoriesCount": 2,
  "categories": [
    {
      "id": 111111,
      "handle": "best-sellers",
      "title": "Best Sellers",
      "url": "https://store.myshopify.com/collections/best-sellers"
    },
    {
      "id": 222222,
      "handle": "electronics",
      "title": "Electronics",
      "url": "https://store.myshopify.com/collections/electronics"
    }
  ]
}
```

#### Collection Data

```json
{
  "type": "collection",
  "id": 123456,
  "handle": "best-sellers",
  "title": "Best Sellers",
  "url": "https://store.myshopify.com/collections/best-sellers",
  "description": "Our top selling products...",
  "productsCount": 24,
  "updatedAt": "2024-03-15T12:00:00Z"
}
```

### Anti-Bot Protection Bypass

This actor implements multiple techniques to bypass Shopify's anti-bot protection:

1. **Randomized Headers**: Uses realistic browser headers that rotate with each request
2. **User-Agent Rotation**: Cycles through multiple modern browser user agents
3. **Rate Limiting**: Smart delays between requests (1-3 seconds)
4. **Retry Logic**: Exponential backoff for rate-limited requests
5. **Proxy Support**: Compatible with Apify's residential proxy network
6. **JSON API Access**: Uses Shopify's public JSON endpoints (faster and more reliable)

#### Recommended Proxy Configuration

For stores with strict bot protection, use residential proxies:

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Currency Support

The actor supports Shopify's multi-currency feature. Simply specify the desired currency code:

```json
{
  "currency": "EUR"
}
```

Supported currencies include: USD, EUR, GBP, CAD, AUD, JPY, and all other ISO 4217 currency codes.

### Stock Status Detection

The actor automatically detects product availability:

- **InStock**: Product or at least one variant is available
- **OutOfStock**: All variants are unavailable

Stock detection includes:

- Variant-level availability
- Inventory quantities
- Inventory management settings
- Product-level availability flags

### Performance & Limits

- **Speed**: ~500-1000 products per minute (depending on store and proxy)
- **Scalability**: Handles stores with 100,000+ products
- **Memory**: ~256MB RAM recommended
- **Timeout**: 30 seconds per request with automatic retries

### Best Practices

1. **Use Proxies**: Enable residential proxies for stores with strict protection
2. **Limit Products**: Use `maxProducts` for testing to avoid long runs
3. **Currency**: Always specify currency for accurate pricing
4. **Rate Limiting**: The actor automatically handles rate limiting - don't reduce delays
5. **Error Handling**: Check actor logs for any failed requests

### Troubleshooting

#### Access Denied (403 Error)

- Enable residential proxies in proxy configuration
- Some stores block datacenter IPs

#### Rate Limited (429 Error)

- The actor automatically handles this with exponential backoff
- Consider reducing concurrent requests if issues persist

#### Missing Products

- Some products may be unlisted or password-protected
- Check if the store requires authentication

#### Incorrect Prices

- Verify the currency code is correct
- Some stores may not support all currencies

### SEO Keywords

shopify scraper, shopify product scraper, shopify data extraction, shopify api scraper, ecommerce scraper, product price monitoring, shopify inventory scraper, shopify collection scraper, shopify store data, extract shopify products, shopify web scraping, apify shopify, shopify crawler, shopify product extractor, shopify data mining

### Support & Feedback

- **Issues**: Report bugs via GitHub or Apify Console
- **Feature Requests**: Suggest improvements in the actor discussion
- **Documentation**: Full API docs available on Apify

### License

Apache-2.0

***

**Ready to extract Shopify data?** Click the "Try for free" button and start scraping in minutes!

# Actor input Schema

## `startUrls` (type: `array`):

List of Shopify store URLs to scrape (e.g., https://example.myshopify.com)

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

Choose what to scrape from the store

## `collectionUrls` (type: `array`):

Specific collection URLs to scrape products from. Only used when mode is PRODUCTS. Example: https://store.myshopify.com/collections/best-sellers

## `productUrls` (type: `array`):

Specific product URLs to scrape. Only used when mode is SINGLE\_PRODUCT. Example: https://store.myshopify.com/products/product-name

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

ISO currency code for prices (e.g., USD, EUR, GBP, CAD, AUD). Leave empty for store default.

## `checkStock` (type: `boolean`):

Detect if products are in stock or out of stock

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

Maximum number of products to scrape (leave empty for unlimited)

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

Maximum number of collections to scrape (leave empty for unlimited)

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

Include all product variants with individual pricing and inventory data

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

Include all product images with metadata (URL, dimensions, alt text)

## `includeDescription` (type: `boolean`):

Include full product descriptions (text and HTML)

## `includeCategories` (type: `boolean`):

Include the collections/categories that each product belongs to. Note: This may slow down scraping as it requires fetching all collections.

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

Proxy settings. Recommended to use residential proxies for stores with strict bot protection.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.myshopify.com/"
    }
  ],
  "mode": "PRODUCTS",
  "currency": "USD",
  "checkStock": true,
  "includeVariants": true,
  "includeImages": true,
  "includeDescription": true,
  "includeCategories": false
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://example.myshopify.com/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xquantify/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 = { "startUrls": [{ "url": "https://example.myshopify.com/" }] }

# Run the Actor and wait for it to finish
run = client.actor("xquantify/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 '{
  "startUrls": [
    {
      "url": "https://example.myshopify.com/"
    }
  ]
}' |
apify call xquantify/shopify-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xquantify/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/E09U2YLdTrR9hjXfu/builds/cpJ5G9A4EkkclcbOo/openapi.json