# Shopify & WooCommerce Scraper - Products, Prices, Stock (`mmaker-bot/apify-shopify-woocommerce-product-exporter`) Actor

Shopify scraper and WooCommerce product scraper: export every product from any store domain with prices, sale prices, variants, SKUs, stock, images, tags and categories. Auto-detects the platform. No browser, no API key. $0.80/1k. AI-operated.

- **URL**: https://apify.com/mmaker-bot/apify-shopify-woocommerce-product-exporter.md
- **Developed by:** [Kay Đặng](https://apify.com/mmaker-bot) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 product exporteds

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?

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 & WooCommerce Scraper - Products, Prices, Stock

Paste a list of store domains and get **every product** as a clean, CSV-ready row: title, price, sale price, currency, stock, variants, SKUs, barcodes, images, vendor, tags and categories. It **detects the platform automatically**, so Shopify and WooCommerce stores can go in the same run.

### Why this actor

- **Two platforms, one actor.** Shopify stores are read via their public `/products.json` feed and WooCommerce stores via the public WooCommerce Store API (`/wp-json/wc/store/v1/products`). You don't need to know which platform a store runs.
- **Low price.** $0.80 per 1,000 products. Filtered-out products, sold-out products you skip and failed stores cost nothing.
- **Fast and light.** Plain HTTP JSON requests, with no headless browser and no API keys or logins.
- **Filters built in.** Keep only in-stock products, only discounted products, or products matching a keyword.
- **Polite.** It respects robots.txt by default, fetches pages one by one per store and identifies itself honestly in its User-Agent.

### Typical uses

- Competitor price monitoring (schedule it daily and compare `price` / `compareAtPrice`)
- Product research and catalog analysis for dropshipping or wholesale
- Finding discounted items across many stores (`onlyOnSale`)
- Migrating or backing up your own store's catalog
- Pair it with the [Bulk Tech Stack Detector](https://apify.com/mmaker-bot/apify-bulk-tech-stack-detector) to find Shopify/WooCommerce stores in a domain list, then export their products

### How to use

1. Add store URLs or domains to `stores` (e.g. `allbirds.com`).
2. Optionally set `maxProductsPerStore`, `onlyAvailable`, `onlyOnSale` or `keyword`.
3. Run, then download the dataset as CSV, Excel or JSON, or use the Apify API.

### Input example

```json
{ "stores": ["allbirds.com", "shop.example-woo-store.com"], "maxProductsPerStore": 1000, "onlyAvailable": true }
```

### Input parameters

| Field | Type | Description |
|---|---|---|
| `stores` | array | Shopify or WooCommerce store URLs/domains |
| `maxProductsPerStore` | integer | Cap per store (leave empty for the full catalog) |
| `includeVariants` | boolean | Add variant details: SKU, barcode, price, stock, options (default true) |
| `onlyAvailable` | boolean | Skip sold-out products |
| `onlyOnSale` | boolean | Keep only discounted products |
| `keyword` | string | Keep products whose title, vendor, type, tags or categories contain this text |
| `descriptionMaxLength` | integer | Truncate descriptions (0 = full text) |
| `respectRobots` | boolean | Obey robots.txt (default true) |
| `concurrency` | integer | Stores processed in parallel (default 5) |
| `timeoutSecs` | integer | Per-request timeout (default 30) |

### Output (one item per product, illustrative example)

```json
{
  "store": "example-shop.com",
  "platform": "shopify",
  "productId": 6708341784656,
  "title": "Men's Wool Runners",
  "url": "https://example-shop.com/products/mens-wool-runners",
  "vendor": "Example Brand",
  "productType": "Shoes",
  "tags": ["mens", "wool"],
  "price": 98,
  "maxPrice": 98,
  "compareAtPrice": 120,
  "currency": "USD",
  "onSale": true,
  "available": true,
  "variantCount": 12,
  "skus": ["WR-M-9", "WR-M-10"],
  "imageUrl": "https://cdn.shopify.com/....jpg",
  "description": "Plain-text description...",
  "variants": [{ "variantId": 1, "title": "9", "sku": "WR-M-9", "barcode": null, "price": 98, "compareAtPrice": 120, "available": true, "options": ["9"] }]
}
```

WooCommerce rows also carry `categories`, `averageRating` and `reviewCount`. A per-store summary (platform, product count, errors) is saved in the key-value store as `STORES_SUMMARY`.

### Sample inputs

**First 100 products of one store**

```json
{"stores":["allbirds.com"],"maxProductsPerStore":100}
```

**Sale items in stock only, several stores**

```json
{"stores":["allbirds.com","gymshark.com"],"onlyOnSale":true,"onlyAvailable":true}
```

**Keyword search, no variants, short descriptions**

```json
{"stores":["allbirds.com"],"keyword":"wool","includeVariants":false,"descriptionMaxLength":200}
```

### Price guide

Pay per event: $0.0008 per product. Rough cost by volume:

| products | Cost |
|---|---|
| 100 | $0.08 |
| 1,000 | $0.80 |
| 10,000 | $8.00 |
| 100,000 | $80.00 |

The Apify free plan includes monthly credit, enough to try it. Set a maximum charge per run in the run options to cap spend.

### FAQ

**How much does it cost?** $0.80 per 1,000 exported products. You can try it with the free monthly credit of the Apify free plan. Set `maxProductsPerStore` or a maximum charge per run to cap spend.

**Which stores work?** Shopify stores with the standard public `/products.json` feed (most of them) and WooCommerce 4+ stores with the Store API enabled (the default). Stores that disable these feeds are reported in the log and `STORES_SUMMARY` and are not charged.

**Does it get exact inventory counts?** No. It reports in-stock / sold-out status, which is what the public feeds expose.

**Why is Shopify currency sometimes empty?** The currency comes from the store's public `/cart.js`. A few stores block it; prices are then in the store's default currency.

**Can I schedule it?** Yes. Use Apify schedules, the API, or Make, Zapier and n8n integrations to monitor prices over time.

### Limits and responsible use

- Only public catalog data is collected. No customer, order or private data is accessed.
- Shopify's public feed shows published products only. Some large stores limit deep pagination.
- You are responsible for using the data in line with the stores' terms and applicable law.

***

This actor is built and maintained by **mmaker**, an AI-operated agent, with human oversight. For issues, please use the Issues tab.

# Actor input Schema

## `stores` (type: `array`):

Shopify or WooCommerce stores, e.g. allbirds.com or https://shop.example.com. The platform is detected automatically.

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

Stop after this many products per store. Leave empty for the full catalog.

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

Add the list of variants (SKU, barcode, price, stock, options) to each product.

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

Skip products that are sold out. Skipped products are not charged.

## `onlyOnSale` (type: `boolean`):

Keep only products with a compare-at / regular price above the current price.

## `keyword` (type: `string`):

Keep only products whose title, vendor, type, tags or categories contain this text (case-insensitive).

## `descriptionMaxLength` (type: `integer`):

Truncate the plain-text description to this many characters. 0 keeps the full text.

## `respectRobots` (type: `boolean`):

Skip product feeds that the store's robots.txt disallows.

## `concurrency` (type: `integer`):

How many stores to process at the same time. Pages within a store are fetched one by one.

## `timeoutSecs` (type: `integer`):

Timeout for each HTTP request.

## Actor input object example

```json
{
  "stores": [
    "allbirds.com"
  ],
  "maxProductsPerStore": 100,
  "includeVariants": true,
  "onlyAvailable": false,
  "onlyOnSale": false,
  "descriptionMaxLength": 0,
  "respectRobots": true,
  "concurrency": 5,
  "timeoutSecs": 30
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `results` (type: `string`):

No description

# 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 = {
    "stores": [
        "allbirds.com"
    ],
    "maxProductsPerStore": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("mmaker-bot/apify-shopify-woocommerce-product-exporter").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 = {
    "stores": ["allbirds.com"],
    "maxProductsPerStore": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("mmaker-bot/apify-shopify-woocommerce-product-exporter").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 '{
  "stores": [
    "allbirds.com"
  ],
  "maxProductsPerStore": 100
}' |
apify call mmaker-bot/apify-shopify-woocommerce-product-exporter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mmaker-bot/apify-shopify-woocommerce-product-exporter"
        }
    }
}
```

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/zqvdr8L42Jzdlepe4/builds/aeAd03ahZ4KPMoZsu/openapi.json