# Woocommerce Scraper (`scrapeflow/woocommerce-scraper`) Actor

🛍️ WooCommerce Scraper (woocommerce-scraper) extracts product titles, prices, stock, variants, categories, images, reviews & URLs from WooCommerce stores. ⚡ Ideal for SEO, price tracking, competitor research & catalog import. CSV/JSON export, scheduling, scaling. 🔄

- **URL**: https://apify.com/scrapeflow/woocommerce-scraper.md
- **Developed by:** [ScrapeFlow](https://apify.com/scrapeflow) (community)
- **Categories:** Automation, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### Woocommerce Scraper

Woocommerce Scraper is a production-ready Apify actor that extracts structured data from WooCommerce stores via public REST endpoints. It solves the challenge of automating WooCommerce data extraction at scale — from prices and stock to categories, tags, and media — making it ideal for marketers, developers, data analysts, and researchers. Use this WooCommerce product scraper to power SEO research, competitive monitoring, and catalog imports across multiple stores with repeatable workflows and robust reliability.

### What is Woocommerce Scraper?

Woocommerce Scraper is a scalable WooCommerce scraping tool that fetches products and other resources from WooCommerce stores through public “wc/store” and “wp/v2” endpoints. It addresses the need to scrape WooCommerce products and metadata reliably (including prices, stock status, categories, tags, images, and reviews) without manual copy-paste or browser automation. Built for marketers, analysts, developers, and researchers, this WooCommerce store scraper enables large-scale data collection, filtering, and export for SEO, price tracking, competitor research, and catalog imports.

### What data / output can you get?

Below are the primary fields the actor outputs when scraping products. Fields are returned as found in the store’s API, cleaned by default, and enriched with the source store URL and resource type.

| Data field | Description | Example value |
| --- | --- | --- |
| url | Product page URL | https://example.com/product/example-product |
| id | Product ID | 12345 |
| name | Product name | Example Product |
| slug | Product slug | example-product |
| type | Product type (simple, variable, etc.) | simple |
| sku | Stock-keeping unit | SKU-001 |
| on_sale | Whether the product is on sale | false |
| prices.price | Current price (string) | 29.99 |
| prices.regular_price | Regular price (string) | 29.99 |
| prices.currency_code | Currency code | USD |
| average_rating | Average rating (string) | 4.5 |
| review_count | Number of reviews | 10 |
| is_in_stock | Availability flag | true |
| images[] | Array of image objects | [{"id":1,"src":"https://…/image.jpg"}] |
| categories[] | Array of category terms | [{"id":12,"slug":"accessories"}] |
| tags[] | Array of tag terms | [{"id":34,"slug":"summer"}] |
| brands[] | Array of brand terms | [{"id":7,"slug":"acme"}] |
| attributes[] | Product attributes/options | [{"id":1,"name":"Color","options":["Red","Blue"]}] |
| add_to_cart | Add-to-cart metadata | {"minimum":1,"maximum":10,"url":"…"} |
| store | Source store URL | https://example.com |
| resource_type | Scraped resource | products |

Notes:
- Additional product fields include: parent, variation, short_description, description, prices.price_range, prices.currency_symbol, prices.currency_prefix, prices.currency_suffix, prices.currency_minor_unit, prices.currency_decimal_separator, prices.currency_thousand_separator, variations, grouped_products, has_options, is_purchasable, is_on_backorder, low_stock_remaining, sold_individually, stock_availability, extensions.
- For non-product resources (e.g., categories, reviews, pages, posts, comments, users), the actor returns the resource’s fields as-is from the API, plus store and resource_type.
- You can export your dataset to JSON or CSV from the Apify platform.

### Key features

- ⚡️ Automatic proxy fallback for resilience  
  Built-in logic escalates from no proxy → datacenter → residential, with retries, to reduce blocking and keep your runs stable.

- 📦 Multi-store batch processing  
  Add multiple store URLs via startUrls, url, or dev_fileupload to scrape several WooCommerce catalogs in a single run.

- 🎯 Powerful filtering & sorting  
  Filter by featured and on-sale products, SKU, rating, tax class, min/max price, category, tag, product type, status, and stock. Sort by date, modified, id, title, slug, price, popularity, rating, menu_order, or comment_count.

- 🧱 Resource flexibility beyond products  
  Select from products, categories, brands, tags, attributes, reviews, pages, posts, comments, post-categories, post-tags, or users.

- 📝 Clean, formatted descriptions  
  Choose output format for descriptions and content: md (Markdown), text (plain), or html.

- 🧩 Field selection & transformations  
  Use dev_transform_fields to select only specific output fields (supports dot notation and array indices).

- 🗂️ Custom storage & safe restarts  
  Save to a custom-named dataset (dev_dataset_name), clear datasets before runs (dev_dataset_clear), and benefit from incremental pushing to avoid data loss.

- 🌐 Custom networking controls  
  Configure proxy settings (proxyConfiguration or dev_proxy_config), and optionally send custom HTTP headers/cookies.

- 🧪 Production-ready reliability  
  Includes retry logic, robust error handling, and real-time logging. Ideal for continuous price monitoring, catalog maintenance, and analytics pipelines.

### How to use Woocommerce Scraper - step by step

1. Create or log in to your Apify account.  
2. Open the “woocommerce-scraper” actor in Apify Console.  
3. Add your store URLs in startUrls (string list) or use url as an alternative. You can also provide a file/URL with dev_fileupload to bulk-load URLs.  
4. Choose the resource to scrape (resource), e.g., products (default), and set limit (1–1000).  
5. Configure filters as needed: featured, sale, search, sku, rating, min_price, max_price, tax_class, category, tag, product_type, status, stock, include_variations, and sorting (sort + order).  
6. Select description format (format): md, text, or html.  
7. Optionally set proxyConfiguration or dev_proxy_config and add extra headers/cookies (dev_custom_headers, dev_custom_cookies).  
8. Click Start to run the actor and monitor logs for progress.  
9. When finished, open the Dataset to view results and export to JSON or CSV.

Pro Tip: Use dev_transform_fields (e.g., url,name,prices.price) to output only the fields you need, and dev_dataset_name (e.g., data-{ACTOR}-{DATE}-{TIME}) for clean, time-stamped storage.

### Use cases

| Use case | Description |
| --- | --- |
| SEO content enrichment | Aggregate product names, descriptions, categories, tags, and images to enrich on-site content and metadata. |
| Price monitoring & alerts | Track prices and on_sale state across stores with a reliable WooCommerce price scraper for competitive intelligence. |
| Competitor catalog analysis | Compare SKUs, product types, and inventory across competitors to inform assortment and merchandising. |
| Catalog import & PIM sync | Export product data to JSON/CSV and feed into PIM/ERP for catalog onboarding or updates. |
| Inventory tracking | Check is_in_stock and related stock availability to monitor inventory changes by category or brand. |
| Market & academic research | Collect structured datasets from multiple stores for trend analysis and research projects. |
| API pipelines & ETL | Integrate via the Apify API with your Python workflows for automated WooCommerce API data extraction. |

### Why choose Woocommerce Scraper?

Woocommerce Scraper is built for precision, automation, and scale — a robust alternative to browser extensions and fragile scripts.

- ✅ Accurate, structured output with rich price, stock, and taxonomy data
- 🌍 Multi-store coverage with flexible resource selection (products to posts)
- 📈 Scales with proxy fallback and retry logic for continuous operations
- 💻 Developer-friendly via Apify API; ideal for Python WooCommerce scraper workflows
- 🔒 Public data only by default for safer, ethical operations
- 💸 Cost-effective for repeated runs like SEO audits, competitor research, and catalog updates
- 🔌 Works with your automation stack (export to CSV/JSON for tools like Make, n8n, Zapier)

In short, it’s a best-in-class WooCommerce product scraping plugin alternative for stable, repeatable data extraction.

### Is it legal / ethical to use Woocommerce Scraper?

Yes — when done responsibly. This actor accesses publicly available WooCommerce endpoints and does not log into private accounts or bypass authentication.

Guidelines for compliant use:
- Scrape only publicly accessible data.
- Respect target websites’ terms of service and robots.txt.
- Avoid collecting personal data and ensure compliance with GDPR/CCPA and similar regulations.
- Consult your legal team for edge cases or regulated use.

### Input parameters & output format

Example JSON input
```json
{
  "startUrls": [
    "https://woocommerce.com",
    "https://example-store.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "limit": 50,
  "resource": "products",
  "include_variations": false,
  "format": "md",
  "sort": "date",
  "order": "",
  "search": "shirt",
  "sku": "SKU-001,SKU-002",
  "rating": "4,5",
  "min_price": 10,
  "max_price": 200,
  "tax_class": "standard",
  "category": "12,34",
  "tag": "56",
  "product_type": "simple",
  "status": "publish",
  "stock": "instock",
  "featured": false,
  "sale": false,
  "dev_proxy_config": "socks5://example.com:9000",
  "dev_custom_headers": "[{\"name\": \"Authorization\", \"value\": \"Bearer token\"}]",
  "dev_custom_cookies": "[{\"name\": \"session\", \"value\": \"abc123\"}]",
  "dev_transform_fields": "url,name,prices.price",
  "dev_dataset_name": "data-{ACTOR}-{DATE}-{TIME}",
  "dev_dataset_clear": false,
  "dev_no_strip": false,
  "dev_fileupload": "https://example.com/store-urls.txt"
}
````

All input fields

- startUrls (array) — 💡 Where do you want to Shop? (Also accepts 'url' as array of store URLs). Required: Yes. Default: none.
- url (array) — Alternative to startUrls: array of store URLs to scrape. Required: No. Default: none.
- limit (integer) — Number of results (per-query). Required: No. Default: 20 (min: 1, max: 1000).
- resource (string) — Select resource type to scrape. One of: products, categories, brands, tags, attributes, reviews, pages, posts, comments, post-categories, post-tags, users. Required: No. Default: products.
- include\_variations (boolean) — Include product variations in results. Required: No. Default: false.
- format (string) — Output format for Descriptions. One of: md, text, html. Required: No. Default: md.
- sort (string) — Sort results by attribute. One of: "", date, modified, id, include, title, slug, price, popularity, rating, menu\_order, comment\_count. Required: No. Default: date.
- order (string) — Order sort direction. One of: "", asc, desc. Required: No. Default: "".
- search (string) — Limit results to those matching a string. Required: No. Default: none.
- sku (string) — Limit result set to products with specific SKU(s). Use commas to separate. Required: No. Default: none.
- rating (string) — Filter by product ratings. Enter comma-separated rating values (e.g., 1,2,3,4,5). Required: No. Default: none.
- min\_price (integer) — Limit result set to products based on a minimum price. Required: No. Default: none.
- max\_price (integer) — Limit result set to products based on a maximum price. Required: No. Default: none.
- tax\_class (string) — Limit result set to products with a specific tax class. One of: "", standard, reduced-rate, zero-rate. Required: No. Default: none.
- category (string) — Product Category ID(s) separated by comma. Required: No. Default: none.
- tag (string) — Product Tag ID(s) separated by comma. Required: No. Default: none.
- product\_type (string) — Products assigned a specific type. One of: "", simple, grouped, external, variable, wbs\_bundle, variation. Required: No. Default: none.
- status (string) — Filter by product status. One of: "", future, trash, draft, pending, private, publish. Required: No. Default: none.
- stock (string) — Filter by stock status. One of: "", instock, outofstock, onbackorder. Required: No. Default: none.
- featured (boolean) — Featured products. Required: No. Default: false.
- sale (boolean) — Products on sale. Required: No. Default: false.
- proxyConfiguration (object) — Choose which proxies to use. By default, no proxy is used. Required: No. Default: {"useApifyProxy": false}.
- dev\_proxy\_config (string) — Supported protocol: HTTP(S), SOCKS5. Example format: socks5://example.com:9000. Required: No. Default: none.
- dev\_custom\_headers (string) — Additional HTTP Headers as JSON array (string). Required: No. Default: none.
- dev\_custom\_cookies (string) — Additional HTTP Cookies as JSON array (string). Required: No. Default: none.
- dev\_transform\_fields (string) — Transform the resulting output. Enter comma-separated field paths (dot notation for objects; numeric indices for arrays). Required: No. Default: none.
- dev\_dataset\_name (string) — Save results into custom named Dataset; supports {ACTOR}, {DATE}, {TIME}. Required: No. Default: none.
- dev\_dataset\_clear (boolean) — Clear Dataset before insert/update. Required: No. Default: false.
- dev\_no\_strip (boolean) — Disable data cleansing (keep empty values). Required: No. Default: false.
- dev\_fileupload (string) — Upload your file and paste the URL to load store URLs. Required: No. Default: none.

Example JSON output (products)

```json
{
  "url": "https://example.com/product/example-product",
  "id": 12345,
  "name": "Example Product",
  "slug": "example-product",
  "parent": 0,
  "type": "simple",
  "variation": "",
  "sku": "SKU-001",
  "short_description": "Short summary of the product.",
  "description": "**Full description** with details and features.",
  "on_sale": false,
  "prices": {
    "price": "29.99",
    "regular_price": "29.99",
    "sale_price": "0",
    "price_range": null,
    "currency_code": "USD",
    "currency_symbol": "$",
    "currency_minor_unit": 2,
    "currency_decimal_separator": ".",
    "currency_thousand_separator": ",",
    "currency_prefix": "$",
    "currency_suffix": ""
  },
  "average_rating": "4.5",
  "review_count": 10,
  "images": [
    { "id": 1, "src": "https://example.com/wp-content/uploads/image.jpg", "alt": "Example" }
  ],
  "categories": [
    { "id": 12, "name": "Accessories", "slug": "accessories" }
  ],
  "tags": [
    { "id": 34, "name": "Summer", "slug": "summer" }
  ],
  "brands": [
    { "id": 7, "name": "Acme", "slug": "acme" }
  ],
  "attributes": [
    { "id": 1, "name": "Color", "options": ["Red", "Blue"] }
  ],
  "variations": [],
  "grouped_products": [],
  "has_options": false,
  "is_purchasable": true,
  "is_in_stock": true,
  "is_on_backorder": false,
  "low_stock_remaining": null,
  "sold_individually": false,
  "stock_availability": { "class": "in-stock", "text": "" },
  "add_to_cart": {
    "minimum": 1,
    "maximum": 10,
    "multiple_of": 1,
    "single_text": "Add to cart",
    "url": "https://example.com/?add-to-cart=12345"
  },
  "extensions": {
    "bundles": [],
    "compatibility": { "host": "", "host_slug": "", "vendor_id": 0, "version": "" },
    "dependencies": { "plugins": [], "themes": [] },
    "express": { "plans": "" },
    "marketplace": { "slug": "" }
  },
  "store": "https://example.com",
  "resource_type": "products"
}
```

Notes:

- Output fields may be omitted if empty (cleaned by default). Set dev\_no\_strip to true to keep empty/null values.
- For non-product resources, the actor outputs the resource fields unmodified from the API and adds store and resource\_type.

### FAQ

#### Do I need API keys or a login to use this WooCommerce product scraper?

No. The actor fetches data from publicly accessible WooCommerce REST “store” and WordPress “wp/v2” endpoints and does not require login or private API credentials.

#### Which resources can I scrape besides products?

You can choose the resource input to scrape products, categories, brands, tags, attributes, reviews, pages, posts, comments, post-categories, post-tags, or users. The actor returns each resource’s fields as provided by the API, plus store and resource\_type.

#### How many items can I scrape per store?

The limit parameter controls the maximum number of results per query. It defaults to 20 and supports up to 1000 per run.

#### Can I include or exclude product variations?

Yes. Set include\_variations to true to include variations in results, or false to exclude them from the output.

#### How do I filter by price, SKU, rating, or stock?

Use min\_price and max\_price to constrain price, sku for SKUs, rating for rating values, and stock for stock status (instock, outofstock, onbackorder). You can also filter by featured and sale.

#### What happens if a store blocks my requests?

The actor includes proxy fallback logic (no proxy → datacenter → residential) with retries. You can also configure proxyConfiguration or provide a custom dev\_proxy\_config.

#### Can I change how descriptions are formatted?

Yes. Use format to choose md (Markdown), text (plain text), or html. The actor applies this to description, short\_description, and content/excerpt fields where applicable.

#### How can I export the results?

After the run, open the Dataset in Apify Console and export your data to JSON or CSV for downstream analysis, PIM/ERP import, or ETL workflows.

### Closing CTA / Final thoughts

Woocommerce Scraper is built for accurate, scalable WooCommerce data extraction. With robust filtering, proxy fallback, and flexible output formatting, it helps marketers, developers, analysts, and researchers automate catalog scraping, price tracking, and competitor analysis across multiple stores. Developers can integrate results via the Apify API to power Python-based pipelines and ETL workflows. Start extracting smarter WooCommerce insights today with a reliable, automation-ready scraper.

# Actor input Schema

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

💡 Where do you want to Shop? (Also accepts 'url' as array of store URLs)

## `url` (type: `array`):

Alternative to startUrls: array of store URLs to scrape.

## `limit` (type: `integer`):

Number of results (per-query)

## `resource` (type: `string`):

Select resource type to scrape

## `include_variations` (type: `boolean`):

Include product variations in results

## `format` (type: `string`):

💡 Output format for Descriptions. (default: Markdown)

## `sort` (type: `string`):

Sort results by attribute

## `order` (type: `string`):

Order sort direction

## `search` (type: `string`):

💡 Limit results to those matching a string.

## `sku` (type: `string`):

💡 Limit result set to products with specific SKU(s). Use commas to separate.

## `rating` (type: `string`):

💡 Filter by product ratings. Enter comma-separated rating values (e.g., 1,2,3,4,5)

## `min_price` (type: `integer`):

Limit result set to products based on a minimum price.

## `max_price` (type: `integer`):

Limit result set to products based on a maximum price.

## `tax_class` (type: `string`):

Limit result set to products with a specific tax class.

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

Product Category ID(s) separated by comma

## `tag` (type: `string`):

Product Tag ID(s) separated by comma

## `product_type` (type: `string`):

Products assigned a specific type

## `status` (type: `string`):

Filter by product status

## `stock` (type: `string`):

Filter by stock status

## `featured` (type: `boolean`):

Featured products

## `sale` (type: `boolean`):

Products on sale

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

Choose which proxies to use. By default, no proxy is used.

## `dev_proxy_config` (type: `string`):

💡 Supported protocol: HTTP(S), SOCKS5
{http|socks5}://{user:pass}@{hostname|ip-address}:port
Example: socks5://example.com:9000

## `dev_custom_headers` (type: `string`):

💡 Additional HTTP Headers as JSON array. Example: \[{"name": "Authorization", "value": "Bearer token"}]

## `dev_custom_cookies` (type: `string`):

💡 Additional HTTP Cookies as JSON array. Example: \[{"name": "session", "value": "abc123"}]

## `dev_transform_fields` (type: `string`):

💡 Transform the resulting output. Enter comma-separated field paths.
For nested object use DOT. For example: address.streetAddress
For nested array use NUMBER (index of array element starting from index=0). For example: images.0.url

## `dev_dataset_name` (type: `string`):

💡 Save results into custom named Dataset, use mask to customize dataset name
{ACTOR} = actor name
{DATE} = date (YYYYMMDD)
{TIME} = time (HHMMSS)
This masks can be used to autogenerate Dataset Name.
example: data-{DATE}
Depending on today date the dataset name will be: data-20230603
default: data-{ACTOR}-{DATE}-{TIME}

## `dev_dataset_clear` (type: `boolean`):

Clear Dataset before insert/update.

## `dev_no_strip` (type: `boolean`):

💡 Keep/Save empty values (NULL, FALSE, empty ARRAY, empty OBJECT, empty STRING)

## `dev_fileupload` (type: `string`):

💡 Upload your file and copy & paste the URL somewhere.

## Actor input object example

```json
{
  "startUrls": [
    "https://woocommerce.com"
  ],
  "limit": 20,
  "resource": "products",
  "include_variations": false,
  "format": "md",
  "sort": "date",
  "order": "",
  "featured": false,
  "sale": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "dev_dataset_clear": false,
  "dev_no_strip": 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": [
        "https://woocommerce.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeflow/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 = {
    "startUrls": ["https://woocommerce.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeflow/woocommerce-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "https://woocommerce.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapeflow/woocommerce-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeflow/woocommerce-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Woocommerce Scraper",
        "description": "🛍️ WooCommerce Scraper (woocommerce-scraper) extracts product titles, prices, stock, variants, categories, images, reviews & URLs from WooCommerce stores. ⚡ Ideal for SEO, price tracking, competitor research & catalog import. CSV/JSON export, scheduling, scaling. 🔄",
        "version": "0.1",
        "x-build-id": "ymO65S9AOfwpEPAyt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflow~woocommerce-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflow-woocommerce-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapeflow~woocommerce-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflow-woocommerce-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapeflow~woocommerce-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflow-woocommerce-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "❓ URL",
                        "type": "array",
                        "description": "💡 Where do you want to Shop? (Also accepts 'url' as array of store URLs)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "url": {
                        "title": "URL (alternative)",
                        "type": "array",
                        "description": "Alternative to startUrls: array of store URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "♾️ Limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Number of results (per-query)",
                        "default": 20
                    },
                    "resource": {
                        "title": "📁 Resource",
                        "enum": [
                            "products",
                            "categories",
                            "brands",
                            "tags",
                            "attributes",
                            "reviews",
                            "pages",
                            "posts",
                            "comments",
                            "post-categories",
                            "post-tags",
                            "users"
                        ],
                        "type": "string",
                        "description": "Select resource type to scrape",
                        "default": "products"
                    },
                    "include_variations": {
                        "title": "Include Variations",
                        "type": "boolean",
                        "description": "Include product variations in results",
                        "default": false
                    },
                    "format": {
                        "title": "Output Format",
                        "enum": [
                            "md",
                            "text",
                            "html"
                        ],
                        "type": "string",
                        "description": "💡 Output format for Descriptions. (default: Markdown)",
                        "default": "md"
                    },
                    "sort": {
                        "title": "Sorting",
                        "enum": [
                            "",
                            "date",
                            "modified",
                            "id",
                            "include",
                            "title",
                            "slug",
                            "price",
                            "popularity",
                            "rating",
                            "menu_order",
                            "comment_count"
                        ],
                        "type": "string",
                        "description": "Sort results by attribute",
                        "default": "date"
                    },
                    "order": {
                        "title": "Order",
                        "enum": [
                            "",
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Order sort direction",
                        "default": ""
                    },
                    "search": {
                        "title": "Search",
                        "type": "string",
                        "description": "💡 Limit results to those matching a string."
                    },
                    "sku": {
                        "title": "SKU",
                        "type": "string",
                        "description": "💡 Limit result set to products with specific SKU(s). Use commas to separate."
                    },
                    "rating": {
                        "title": "Product Ratings",
                        "type": "string",
                        "description": "💡 Filter by product ratings. Enter comma-separated rating values (e.g., 1,2,3,4,5)"
                    },
                    "min_price": {
                        "title": "Price Range - Min",
                        "type": "integer",
                        "description": "Limit result set to products based on a minimum price."
                    },
                    "max_price": {
                        "title": "Price Range - Max",
                        "type": "integer",
                        "description": "Limit result set to products based on a maximum price."
                    },
                    "tax_class": {
                        "title": "Tax Class",
                        "enum": [
                            "",
                            "standard",
                            "reduced-rate",
                            "zero-rate"
                        ],
                        "type": "string",
                        "description": "Limit result set to products with a specific tax class."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Product Category ID(s) separated by comma"
                    },
                    "tag": {
                        "title": "Tag",
                        "type": "string",
                        "description": "Product Tag ID(s) separated by comma"
                    },
                    "product_type": {
                        "title": "Product Type",
                        "enum": [
                            "",
                            "simple",
                            "grouped",
                            "external",
                            "variable",
                            "wbs_bundle",
                            "variation"
                        ],
                        "type": "string",
                        "description": "Products assigned a specific type"
                    },
                    "status": {
                        "title": "Product Status",
                        "enum": [
                            "",
                            "future",
                            "trash",
                            "draft",
                            "pending",
                            "private",
                            "publish"
                        ],
                        "type": "string",
                        "description": "Filter by product status"
                    },
                    "stock": {
                        "title": "Stock Status",
                        "enum": [
                            "",
                            "instock",
                            "outofstock",
                            "onbackorder"
                        ],
                        "type": "string",
                        "description": "Filter by stock status"
                    },
                    "featured": {
                        "title": "Featured",
                        "type": "boolean",
                        "description": "Featured products",
                        "default": false
                    },
                    "sale": {
                        "title": "On Sale",
                        "type": "boolean",
                        "description": "Products on sale",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used."
                    },
                    "dev_proxy_config": {
                        "title": "🌐 PROXY NETWORKING",
                        "type": "string",
                        "description": "💡 Supported protocol: HTTP(S), SOCKS5\n{http|socks5}://{user:pass}@{hostname|ip-address}:port\nExample: socks5://example.com:9000"
                    },
                    "dev_custom_headers": {
                        "title": "📜 HTTP HEADERS",
                        "type": "string",
                        "description": "💡 Additional HTTP Headers as JSON array. Example: [{\"name\": \"Authorization\", \"value\": \"Bearer token\"}]"
                    },
                    "dev_custom_cookies": {
                        "title": "🍰 HTTP COOKIES",
                        "type": "string",
                        "description": "💡 Additional HTTP Cookies as JSON array. Example: [{\"name\": \"session\", \"value\": \"abc123\"}]"
                    },
                    "dev_transform_fields": {
                        "title": "♻️ CUSTOM FIELD",
                        "type": "string",
                        "description": "💡 Transform the resulting output. Enter comma-separated field paths.\nFor nested object use DOT. For example: address.streetAddress\nFor nested array use NUMBER (index of array element starting from index=0). For example: images.0.url"
                    },
                    "dev_dataset_name": {
                        "title": "📁 CUSTOM STORAGE",
                        "type": "string",
                        "description": "💡 Save results into custom named Dataset, use mask to customize dataset name\n{ACTOR} = actor name\n{DATE} = date (YYYYMMDD)\n{TIME} = time (HHMMSS)\nThis masks can be used to autogenerate Dataset Name.\nexample: data-{DATE}\nDepending on today date the dataset name will be: data-20230603\ndefault: data-{ACTOR}-{DATE}-{TIME}"
                    },
                    "dev_dataset_clear": {
                        "title": "Clear Storage",
                        "type": "boolean",
                        "description": "Clear Dataset before insert/update.",
                        "default": false
                    },
                    "dev_no_strip": {
                        "title": "Disable data cleansing",
                        "type": "boolean",
                        "description": "💡 Keep/Save empty values (NULL, FALSE, empty ARRAY, empty OBJECT, empty STRING)",
                        "default": false
                    },
                    "dev_fileupload": {
                        "title": "📁 FILE UPLOADER",
                        "type": "string",
                        "description": "💡 Upload your file and copy & paste the URL somewhere."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
