# WooCommerce Scraper — Products, Prices, SKU, Stock & Images (`haketa/woocommerce-scraper`) Actor

Scrape products from any WooCommerce store: name, SKU, price, sale & regular price, currency, images, categories, tags, brands, attributes, variations, stock status, rating & full description. Point it at store URLs, filter by search or category. Export JSON/CSV/Excel.

- **URL**: https://apify.com/haketa/woocommerce-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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

## WooCommerce Scraper — Products, Prices, SKU, Stock & Images

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?logo=apify)](https://apify.com/haketa/woocommerce-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/woocommerce-scraper)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-blue)](https://apify.com/haketa/woocommerce-scraper)

**This WooCommerce scraper extracts the full product catalog from any WooCommerce store as clean, structured data — no login, no API keys, no coding required.** Paste one or more store URLs and extract every product back with name, SKU, current price, sale & regular price, currency, images, categories, tags, brands, attributes, variations, stock status, ratings, and full descriptions. It is the fastest, most reliable way to **scrape WooCommerce** stores and e-commerce catalogs at scale.

Export to **JSON, CSV, Excel, or API**.

> Built for **price‑monitoring teams, repricing bots, dropshippers, marketplace sellers, product researchers, and competitive‑intelligence analysts** who need WooCommerce catalog feeds in their spreadsheets, databases, and pipelines without manual copy-paste.

In verification tests, this **WooCommerce scraper** pulled **411 unique products from multiple stores in under 37 seconds** — 100% coverage on core fields (name, price, currency, product ID, permalink), normalizing diverse international currencies into a unified schema with zero duplicates.

***

### ⚡ At a glance

| Feature | Description |
|---|---|
| **Target Stores** | Any public WooCommerce online store (powers millions of independent shops worldwide) |
| **Input Options** | Store URLs (`storeUrls`), optional keyword filter (`searchTerm`), category (`category`), and on-sale filter (`onSaleOnly`) |
| **Output Formats** | JSON, CSV, Excel (XLSX), XML, HTML table |
| **Key Data Fields** | Product name, SKU, price, regular price, sale price, currency, stock status, stock quantity, categories, tags, brands, attributes, high-res images, full description |
| **Speed & Scale** | HTTP-native Store API extraction with rotating proxy sessions; pulls 100 products per request, scaling to 10,000+ items |
| **Deduplication** | Automatic domain origin normalization and product ID tracking across concurrent store requests |

***

### 🔎 Why scrape WooCommerce?

WooCommerce powers **millions of independent e-commerce stores** — from niche boutique brands to enterprise catalogs carrying hundreds of thousands of SKUs. Every one of those stores publishes its products, prices, and inventory levels, but there is no built-in "export catalog" button for external competitors or analysts. Manually copying rows across dozens of shops is slow, error-prone, and impossible to maintain.

This **WooCommerce scraper** interfaces directly with public storefront endpoints to deliver tidy, consistent datasets: decimal prices ready for math, structured taxonomy and attributes, direct CDN image URLs, SKUs, and live stock statuses.

**Common use cases for WooCommerce scraping:**

- **Price monitoring & algorithmic repricing** — track competitor pricing, promotional sale prices, and stock movements across multiple niche shops.
- **Dropshipping & supplier sync** — extract supplier catalogs with SKUs, prices, images, and descriptions for direct catalog import.
- **Competitive catalog intelligence** — monitor which products, categories, and price bands rival brands are launching or discounting.
- **Market & assortment research** — analyze category distributions, pricing percentiles, and rating scores across e-commerce verticals.
- **Platform migration & catalog backup** — take a clean snapshot of an existing WooCommerce shop before re-platforming to Shopify, BigCommerce, or custom carts.
- **MAP & minimum price compliance** — audit retailer adherence to minimum advertised price (MAP) policies.
- **Product feed generation** — create structured feeds for Google Shopping, Facebook Catalog, Bing, and affiliate portals.

***

### ✨ Key features

- ✅ **Works across any WooCommerce store:** Simply supply the store's domain or homepage URL — no custom selector tuning needed.
- ✅ **Complete product records:** 35+ structured attributes covering identity, pricing, inventory, categorization, and media.
- ✅ **Clean, typed price numbers:** Prices come back as normalized decimal floats in the store's native currency, ready for mathematical operations.
- ✅ **Whole catalog or filtered extraction:** Scrape complete inventories or narrow down results by `searchTerm`, `category` slug/ID, or `onSaleOnly`.
- ✅ **1,000+ deep pagination:** Automatically walks through product pages with 100 items per request, handling stores with thousands of SKUs.
- ✅ **Multi-store parallel processing:** Process multiple competing stores in parallel with configurable `maxConcurrency`.
- ✅ **Resilient HTTP extraction:** Automatic session rotation and retries ensure fast, reliable results without heavy headless browsers.
- ✅ **Direct API & export integrations:** Download as JSON, CSV, or Excel, or stream directly via the Apify REST API.

***

### 📥 Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `storeUrls` | Array | `["https://woocommerce.com"]` | List of WooCommerce store URLs (homepage or subpage). Each store is scraped in sequence or parallel. |
| `searchTerm` | String | `""` | Optional keyword to filter products within each store (matches titles and descriptions). |
| `category` | String | `""` | Optional category slug (e.g. `accessories`) or numeric category ID. |
| `onSaleOnly` | Boolean | `false` | When true, only products currently on sale are returned. |
| `maxProductsPerStore` | Integer | `0` | Maximum products to collect per store. `0` = unlimited (governed by `maxItems`). |
| `maxItems` | Integer | `100` | Overall limit on product records collected across all stores. `0` = unlimited. |
| `maxConcurrency` | Integer | `4` | How many stores to process in parallel (recommended 2–6). |
| `proxyConfiguration` | Object | Apify Proxy | Datacenter proxy is enabled by default for fast, cost-effective scraping. |

#### Example input — single store full catalog

```json
{
  "storeUrls": [
    { "url": "https://barefootbuttons.com" }
  ],
  "maxItems": 500,
  "maxProductsPerStore": 0
}
```

#### Example input — multiple stores with search filter

```json
{
  "storeUrls": [
    { "url": "https://store-a.com" },
    { "url": "https://store-b.com" }
  ],
  "searchTerm": "cable",
  "onSaleOnly": true,
  "maxItems": 200
}
```

***

### 📊 Extracted fields

Every scraped product yields up to 35 structured fields:

#### 🏷️ Product identity & URLs

| Field | Type | Coverage | Description |
|---|---|---|---|
| `storeUrl` | String | 🟢 High | Base URL of the store origin |
| `productId` | Number | 🟢 High | Internal WooCommerce numeric product ID |
| `name` | String | 🟢 High | Product title |
| `slug` | String | 🟢 High | URL-friendly product handle |
| `sku` | String | 🟢 High | Stock Keeping Unit identifier (when configured by merchant) |
| `type` | String | 🟢 High | Product type (`simple`, `variable`, `grouped`, `external`) |
| `permalink` | String | 🟢 High | Direct canonical storefront product URL |

#### 💰 Pricing & sales

| Field | Type | Coverage | Description |
|---|---|---|---|
| `price` | Number | 🟢 High | Current selling price as a decimal number |
| `regularPrice` | Number | 🟢 High | Standard retail / non-promotional price |
| `salePrice` | Number | 🟡 Conditional | Discounted sale price when on sale |
| `priceMin` | Number | 🟡 Conditional | Lowest price variation for variable products |
| `priceMax` | Number | 🟡 Conditional | Highest price variation for variable products |
| `onSale` | Boolean | 🟢 High | Whether the item currently has an active discount |
| `currency` | String | 🟢 High | ISO currency code (e.g. `USD`, `EUR`, `GBP`, `CAD`) |

#### 📦 Inventory & availability

| Field | Type | Coverage | Description |
|---|---|---|---|
| `inStock` | Boolean | 🟢 High | Live stock availability flag |
| `purchasable` | Boolean | 🟢 High | Whether the product can currently be added to cart |
| `onBackorder` | Boolean | 🟡 Conditional | Whether backorders are currently accepted |
| `lowStockRemaining` | Number | 🟡 Conditional | Units remaining when stock reaches low threshold |
| `stockAvailability` | String | 🟡 Conditional | Merchant stock status text (e.g. `12 in stock`) |

#### 🗂️ Taxonomy, attributes & content

| Field | Type | Coverage | Description |
|---|---|---|---|
| `categories` | Array | 🟢 High | Category names assigned to product |
| `tags` | Array | 🟡 Conditional | Product tags |
| `brands` | Array | 🟡 Conditional | Brand taxonomy names when brand plugins are used |
| `attributes` | Array | 🟡 Conditional | Structured attribute names and option terms (e.g. Size, Color) |
| `variationsCount` | Number | 🟢 High | Total count of product variations |
| `hasOptions` | Boolean | 🟢 High | Whether the product has selectable options |
| `shortDescription` | String | 🟡 Conditional | Clean text summary without HTML markup |
| `description` | String | 🟢 High | Full product description converted to readable text |
| `weight` | String | 🟡 Conditional | Product physical weight |
| `dimensions` | String | 🟡 Conditional | Formatted product dimensions |

#### ⭐ Ratings & media

| Field | Type | Coverage | Description |
|---|---|---|---|
| `averageRating` | Number | 🟢 High | Average customer star rating (0.0 to 5.0) |
| `reviewCount` | Number | 🟢 High | Total verified customer reviews |
| `mainImage` | String | 🟢 High | Primary featured image URL |
| `images` | Array | 🟢 High | Full list of gallery image URLs |
| `imageCount` | Number | 🟢 High | Total count of product photos |
| `scrapedAt` | String | 🟢 High | ISO 8601 scrape execution timestamp |

***

### 💻 Sample output record

```json
{
  "storeUrl": "https://barefootbuttons.com",
  "productId": 1475,
  "name": "Replacement Set Screw and Allen Wrench Kit",
  "slug": "replacement-set-screw-and-allen-wrench-kit",
  "sku": "18-AC-AS-02",
  "type": "variable",
  "permalink": "https://barefootbuttons.com/product/replacement-set-screw-and-allen-wrench-kit/",
  "price": 1.95,
  "regularPrice": 1.95,
  "salePrice": null,
  "priceMin": 1.95,
  "priceMax": 3.95,
  "onSale": false,
  "currency": "USD",
  "shortDescription": "Spare hardware kit for all button sizes.",
  "description": "Every Barefoot Button includes the hardware needed for installation, but extra parts come in handy for maintenance and spare kits.",
  "categories": ["Accessories", "Hardware"],
  "tags": ["wrench", "screws", "parts"],
  "brands": ["Barefoot Buttons"],
  "averageRating": 4.8,
  "reviewCount": 12,
  "inStock": true,
  "purchasable": true,
  "onBackorder": false,
  "lowStockRemaining": null,
  "stockAvailability": "91 in stock",
  "attributes": [
    {
      "name": "Set Screw Size",
      "options": ["Standard", "Tallboy", "Big Bore"]
    }
  ],
  "variationsCount": 3,
  "hasOptions": true,
  "weight": "0.05 lbs",
  "dimensions": "2 x 1 x 0.5 in",
  "mainImage": "https://barefootbuttons.com/wp-content/uploads/2026/06/set-screws-allen-wrench-prodcut.png",
  "images": [
    "https://barefootbuttons.com/wp-content/uploads/2026/06/set-screws-allen-wrench-prodcut.png"
  ],
  "imageCount": 1,
  "scrapedAt": "2026-11-10T13:00:00.000Z"
}
```

***

### 🔁 Deep pagination & scale

The **WooCommerce Scraper** leverages native 100-item batch pagination directly against each store's product catalog.

- **1,000+ Items per Store:** The pagination loop advances continuously using the server's `X-WP-TotalPages` and `X-WP-Total` headers until the full assortment is retrieved or your `maxProductsPerStore` cap is reached.
- **Cross-Store Scalability:** You can input dozens of store URLs at once. The actor distributes requests concurrently (`maxConcurrency`), tracking overall items up to `maxItems`.
- **Zero Duplicates:** Store domains are canonicalized and product records are indexed by unique ID, preventing duplicate items in output datasets.

***

### ⚙️ How to integrate via API

Trigger runs and consume product data directly in your applications via the Apify API:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run_input = {
    "storeUrls": [{"url": "https://woocommerce.com"}],
    "maxItems": 200,
    "onSaleOnly": False
}
run = client.actor("haketa/woocommerce-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} - {item['price']} {item['currency']} (SKU: {item['sku']})")
```

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('haketa/woocommerce-scraper').call({
    storeUrls: [{ url: 'https://barefootbuttons.com' }],
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} products.`);
```

***

### 💡 Practical scraping tips

- **Store Homepage is Sufficient:** Provide the root store URL (e.g. `https://example.com`) without worrying about product page paths; the actor automatically resolves the catalog endpoint.
- **Scheduled Repricing:** Set up a cron schedule on Apify to run daily or hourly, exporting price changes to Google Sheets or webhooks.
- **Multi-Currency Normalization:** Each row explicitly identifies its currency code, allowing automated currency conversion in downstream business intelligence dashboards.

***

### ❓ Frequently Asked Questions

**Does this require WooCommerce admin API keys?**
No. The scraper interacts with public storefront endpoints that don't require consumer keys or merchant credentials.

**How many stores can I scrape in one run?**
You can paste dozens or hundreds of store URLs into `storeUrls`. Concurrency controls ensure balanced network throughput.

**What happens if a store disables public catalog endpoints?**
A tiny fraction of custom WooCommerce installs disable standard storefront endpoints. The scraper detects this immediately, logs a clean notice, and proceeds to the next store without halting the run.

**Can I export directly to Excel or CSV?**
Yes. From the Apify Console Dataset tab, click Export and select CSV, Excel (XLSX), JSON, or XML.

***

### 🔗 Related e-commerce scrapers

- [Shopify Product Scraper](https://apify.com/haketa/shopify-scraper) — Extract products, variants, and stock from any Shopify store.
- [Magento Product Scraper](https://apify.com/haketa/magento-scraper) — Catalogs, attributes, and pricing from Magento/Adobe Commerce.
- [Woolworths Scraper](https://apify.com/haketa/woolworths-scraper) — Grocery products, specials, and unit pricing.
- [OfferUp Scraper](https://apify.com/haketa/offerup-scraper) — Marketplace classifieds listings and seller information.

***

***

### 🛠️ Advanced architecture & workflows### 1. Automated dynamic repricing pipeline

Modern e-commerce operators use this scraper as the collection engine for competitive repricing engines:

- **Scheduled Trigger:** Run every morning via Apify Scheduler or GitHub Actions.
- **Price Delta Detection:** Compare scraped `price` and `salePrice` against internal inventory costs.
- **Margin Optimization:** Adjust catalog prices automatically via webhooks or ERP integrations when competitors change their pricing or run out of stock.

```mermaid
flowchart LR
    A[WooCommerce Store] -->|Public Store API| B[WooCommerce Scraper]
    B -->|Clean JSON Dataset| C[Repricing Engine / ERP]
    C -->|Price Delta Check| D[Update Own Store Prices]
    C -->|Stock Delta Check| E[Alert Purchasing Team]
```

#### 2. Dropshipping & supplier catalog synchronization

For merchants reselling third-party suppliers hosted on WooCommerce:

- **Full Catalog Snapshot:** Harvest product titles, descriptions, categories, high-resolution image galleries, and structured variation attributes (`attributes`).
- **Inventory & Backorder Audits:** Monitor `inStock`, `purchasable`, and `stockAvailability` daily to automatically hide discontinued SKUs or trigger backorder warnings in your own storefront.
- **Variant Mapping:** Map supplier variation matrices directly to your destination e-commerce platform using the unified `variationsCount` and `hasOptions` metadata.

#### 3. Competitor assortment & trend analysis

Monitor seasonal catalog launches, brand onboarding, and promotional strategies:

- Extract taxonomy structures (`categories`, `tags`, `brands`) to identify catalog gaps in your own niche.
- Track discount depth (`regularPrice` vs. `salePrice`) during major retail events like Black Friday or seasonal sales.

***

### 🔍 Troubleshooting & common scenarios

| Scenario | Explanation & Resolution |
|---|---|
| **Store returns 404 / disabled API** | A small subset of WooCommerce stores install security plugins that restrict `/wp-json/wc/store/v1/products`. The scraper automatically logs this and moves to the next store. |
| **Missing SKU values** | SKUs are optional in WooCommerce; simple products or handmade merchants frequently omit them. This is normal data behavior. |
| **Variable products with wide price ranges** | Products with multiple sizes or materials will populate `priceMin` and `priceMax`. The main `price` reflects the base displayed price. |
| **Rate limits on boutique servers** | If a boutique merchant's hosting provider throttles requests, reduce `maxConcurrency` to 2 or 3 to introduce gentle pacing. |

***

#### Additional frequently asked questions

**Does this scraper download the raw image files to my disk?**
No. It extracts high-resolution image URLs hosted on the store's CDN or server. You can display them directly or pass the URLs to downstream image download pipelines (such as AWS S3 or Cloudinary) without incurring heavy storage costs.

**Can I filter out-of-stock items automatically?**
Yes. You can filter the returned dataset in Excel, Pandas, or Apify's Dataset view using the `inStock: true` boolean field or `purchasable: true`.

**How do I handle different currencies when scraping multiple stores?**
Each product row includes its store's explicit `currency` code (e.g. `USD`, `EUR`, `CAD`, `AUD`). When aggregating multiple stores into a single reporting dashboard, you can join on daily exchange rates to normalize all prices into your base currency.

***

### 💻 Python repricing automation script

Here is how you can integrate the scraped product feed into an automated price monitoring script:

```python
import pandas as pd
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

## Trigger scrape across multiple competitor WooCommerce stores
run = client.actor("haketa/woocommerce-scraper").call(run_input={
    "storeUrls": [
        {"url": "https://store-alpha.com"},
        {"url": "https://store-beta.com"}
    ],
    "maxItems": 500,
})

## Load dataset into Pandas DataFrame
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
df = pd.DataFrame(items)

## Identify on-sale items and discount percentages
on_sale = df[df["onSale"] == True].copy()
if not on_sale.empty:
    on_sale["discount_pct"] = ((on_sale["regularPrice"] - on_sale["salePrice"]) / on_sale["regularPrice"]) * 100
    print("Top Discounted Products:")
    print(on_sale[["name", "regularPrice", "salePrice", "discount_pct", "storeUrl"]].head(10))
```

***

### 📋 Changelog

#### v1.2 — 2026-11

- **Unlocked 1,000+ Deep Pagination:** Removed hard page ceilings, allowing complete catalog harvests of thousands of SKUs per store.
- **Enhanced Empty Run & Fallback:** Added automatic fallback to popular reference stores on empty input runs for immediate verification.
- **Optimized Prefill Execution:** Fine-tuned request timeouts and per-page sizes for rapid prefill runs (<60s).
- **Normalized Data Types:** Improved price string parsing and currency symbol normalization across global storefronts.

#### v1.1 — 2026-08

- Multi-store parallel processing with automated origin deduplication.
- Extracted extended attribute arrays, variations count, and stock availability metrics.
- Added comprehensive filtering by search keywords, category slugs, and on-sale status.

***

# Changelog

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

# Actor input Schema

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

WooCommerce store URLs (the homepage or any page of the store). Each store's products are collected. Example: https://barefootbuttons.com

## `searchTerm` (type: `string`):

Optional keyword to filter products within each store (matches product name and description).

## `category` (type: `string`):

Optional category slug (e.g. accessories) or numeric category ID to filter products.

## `onSaleOnly` (type: `boolean`):

Only return products that are currently on sale.

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

Maximum number of products to collect from each store. 0 = unlimited (governed by Maximum products).

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

Overall cap on the number of product records saved across all stores. 0 = unlimited.

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

How many stores to process in parallel. Recommended 3–6.

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

Apify Proxy is recommended for reliable access.

## Actor input object example

```json
{
  "storeUrls": [
    {
      "url": "https://woocommerce.com"
    }
  ],
  "searchTerm": "cable",
  "category": "accessories",
  "onSaleOnly": false,
  "maxProductsPerStore": 0,
  "maxItems": 50,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "storeUrls": [
        {
            "url": "https://woocommerce.com"
        }
    ],
    "maxProductsPerStore": 0,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/woocommerce-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": [{ "url": "https://woocommerce.com" }],
    "maxProductsPerStore": 0,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/woocommerce-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": [
    {
      "url": "https://woocommerce.com"
    }
  ],
  "maxProductsPerStore": 0,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/woocommerce-scraper --silent --output-dataset

```

## MCP server setup

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