# WooCommerce Store Products & Prices Scraper (`atesen-software/woocommerce-store-products-scraper`) Actor

Export product names, SKUs, prices, sale prices, stock, categories and variant options from shops with a public WooCommerce Store API. No API key, browser or proxy needed.

- **URL**: https://apify.com/atesen-software/woocommerce-store-products-scraper.md
- **Developed by:** [Atesen Software](https://apify.com/atesen-software) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 products

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

## WooCommerce Store Products & Prices Scraper

Need the product list and prices of a WooCommerce shop? Paste the shop address and get every product as a clean row: name, SKU, price, sale price, stock, categories, images and variant options. No shop API key, browser or proxy.

Give it one or more WooCommerce shops and get the **product catalogue as clean rows**: **name, URL, SKU, price, regular price, sale price, on-sale flag, currency, stock status, categories, image URLs, attributes, a variations summary, average rating and review count**. It reads the **public WooCommerce Store API** (`/wp-json/wc/store/v1/products`), the same data the shop's own storefront loads, so you need no consumer key, no secret and no login. No browser and no proxy.

- **Real prices, not minor units**: the Store API sends prices as strings in the currency's smallest unit (`"3999"` with `currency_minor_unit` 2). The Actor converts them using the shop's own `currency_minor_unit`, so you get `39.99`.
- **Sale tracking fields**: `price`, `regularPrice`, `salePrice` and `onSale` per product. Variable products also get `priceMin` and `priceMax` when the shop reports a price range.
- **Stock**: `stockStatus` (`in_stock`, `out_of_stock`, `on_backorder`), plus the raw `inStock` and `purchasable` flags.
- **Filters**: a search term, a category (slug, name or ID) and a maximum number of products per shop.
- **Polite**: about one request per second per shop, retries with back-off, and the shop's `robots.txt` is read first and obeyed.
- **Unavailable stores**: when the Store API is missing, blocked or returns HTML, a `status` row records the reason without a product charge.

### Use cases

- **Competitor price monitoring**: run it on a schedule and compare `price`, `salePrice` and `stockStatus` between runs.
- **Catalog sync**: keep a marketplace, a price comparison site or an internal product database in step with the shops you resell or follow.
- **Market research**: see which categories, price points and variants a shop offers, and how well products are rated.

### Input

| Field | Description |
|---|---|
| `shops` | Up to 50 public store domains or HTTP(S) URLs on standard web ports. A shop page URL also works. |
| `searchTerm` | Optional. Only products matching this text, like the shop's own search box. |
| `category` | Optional. Category slug, name or numeric ID; separate several with commas. |
| `maxItemsPerShop` | Default 100. Use `0` to keep paging until the shop ends the catalogue or the run reaches its budget or request limit. |
| `includeDescriptions` | Default on. Adds `shortDescription` and `description` as plain text. |
| `includeShopInfo` | Default on. One free `shop` row per shop. |
| `maxConcurrency` | Shops read in parallel (default 2). Each single shop still gets about one request per second. |

```json
{
  "shops": ["mercantile.wordpress.org", "https://offermanwoodshop.com/shop/"],
  "maxItemsPerShop": 20
}
```

### Output

One row per product. A real row from mercantile.wordpress.org, long text shortened with "…" (variations list shortened to 3 of 4).

```json
{
  "type": "product",
  "shop": "mercantile.wordpress.org",
  "productId": 31032,
  "name": "WordPress Tie Dye Hoodie",
  "slug": "wordpress-tie-dye-hoodie",
  "url": "https://mercantile.wordpress.org/product/wordpress-tie-dye-hoodie/",
  "sku": null,
  "productType": "variable",
  "price": 65,
  "regularPrice": 65,
  "salePrice": null,
  "onSale": false,
  "priceMin": null,
  "priceMax": null,
  "currency": "USD",
  "stockStatus": "in_stock",
  "inStock": true,
  "purchasable": true,
  "lowStockRemaining": null,
  "categories": [
    "Apparel",
    "Unisex"
  ],
  "images": [
    "https://mercantile.wordpress.org/wp-content/uploads/2025/06/Untitled-design-1.png"
  ],
  "attributes": [
    {
      "name": "Size",
      "values": [
        "Adult Unisex 2XL",
        "Adult Unisex 3XL",
        "Adult Unisex LG",
        "Adult Unisex MD",
        "Adult Unisex SM",
        "Adult Unisex XL",
        "Adult Unisex XS"
      ],
      "usedForVariations": true
    },
    {
      "name": "Material",
      "values": [
        "9oz 80% cotton/20% polyester blend. Jersey lined hood. Ring spun cotton. Each garment is dyed by hand and has a unique look. Embroidered logo."
      ],
      "usedForVariations": false
    }
  ],
  "variationCount": 4,
  "variations": [
    {
      "id": 31037,
      "attributes": {
        "Size": "Adult Unisex LG"
      }
    },
    {
      "id": 31038,
      "attributes": {
        "Size": "Adult Unisex XL"
      }
    },
    {
      "id": 31039,
      "attributes": {
        "Size": "Adult Unisex 2XL"
      }
    }
  ],
  "averageRating": 0,
  "reviewCount": 0,
  "shortDescription": "A cozy layer for site builders, slug fixers, and community wanderers.",
  "description": "",
  "input": "https://mercantile.wordpress.org",
  "scrapedAt": "2026-11-15T15:35:01.556Z"
}
```

For variable products, `attributes` lists each option with its values (`{"name": "Sizes", "values": ["L", "M", "S"], "usedForVariations": true}`) and `variations` summarises every variant as `{"id": 43117, "attributes": {"Sizes": "XS", "Colors": "Hunter Green"}}`. `salePrice` is empty unless the product is on sale. On variable products `price` is the price the shop reports (the lowest variant price in our test runs); `priceMin` and `priceMax` show the range when the shop provides one.

Free helper rows share the same dataset:

- `type: "shop"`: `shop`, `storeApi`, `currency`, `productsMatching`, `itemsSaved`, `complete` (false if the Actor could not verify the export reached the end).
- `type: "status"`: `status`, `input`, `message`, and `httpStatus` when the shop answered or the request failed.

Status values you may see: `store_api_missing` (HTTP 404, an HTML page instead of JSON, or WordPress without WooCommerce), `store_api_blocked` (HTTP 401/403), `blocked_by_robots`, `fetch_failed`, `category_not_found`, `empty`, `invalid_url`, `invalid_input`.

```json
{
  "type": "status",
  "status": "store_api_missing",
  "input": "https://example.com",
  "message": "No WooCommerce Store API found at https://example.com/wp-json/wc/store/v1/products (HTTP 404). The site may not run WooCommerce or has switched the Store API off. Not charged.",
  "shop": "example.com",
  "httpStatus": 404,
  "scrapedAt": "2026-10-23T20:53:21.452Z"
}
```

### Limits

- The shop must run WooCommerce with its public Store API on. Shops that block it, or forbid `/wp-json/` in `robots.txt`, return a status row only.
- A run makes up to 1,200 HTTP requests across all shops, including robots checks and redirects. It accepts responses up to 8 MB each.
- If Apify migrates an active run, the Actor keeps the rows already saved. Start a new run for a fresh export.
- Prices are what the Store API shows to an anonymous visitor from the machine that runs the Actor. Shops with multi-currency or geo-based pricing may show another currency than you expect.
- Variations are summarised (ID and option values). Per-variant prices and stock are not included.
- No customer, order or review texts. Only the average rating and review count of each product.

### Use via API

One request runs the Actor, waits for it and returns the dataset items as JSON. Send your token in the `Authorization` header, not in the URL:

```bash
curl -X POST "https://api.apify.com/v2/acts/atesen-software~woocommerce-store-products-scraper/run-sync-get-dataset-items?timeout=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"shops":["mercantile.wordpress.org"],"maxItemsPerShop":20}'
```

The synchronous endpoint waits up to 300 seconds. For longer jobs start a run with `POST https://api.apify.com/v2/acts/atesen-software~woocommerce-store-products-scraper/runs` and read the dataset when it finishes.

**JavaScript** (`npm install apify-client`):

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('atesen-software/woocommerce-store-products-scraper').call({ shops: ["mercantile.wordpress.org"], maxItemsPerShop: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with AI agents (MCP)

Claude Desktop, Cursor, VS Code and other MCP clients can call this Actor as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Load only this Actor with:

```text
https://mcp.apify.com?tools=atesen-software/woocommerce-store-products-scraper
```

Client config (sign in with Apify OAuth when the browser opens, or add an `Authorization: Bearer <APIFY_TOKEN>` header instead):

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=atesen-software/woocommerce-store-products-scraper" }
  }
}
```

Then ask in plain words, for example: "Export 20 products from the WooCommerce shop mercantile.wordpress.org with price and stock." The agent fills the same input fields you see on the Input tab, and runs are billed to your Apify account at the prices on the Pricing tab.

### FAQ

**Do I need WooCommerce API keys?** No. The Actor uses the Store API that WooCommerce publishes for its own storefront and checkout blocks. It needs no consumer key or secret and it cannot reach orders, customers or any private data.

**Why do I get a status row instead of products?** The shop does not offer a public Store API: WooCommerce is not installed, the API is blocked by a security plugin or firewall (HTTP 401/403), the site answers with an HTML page, or its `robots.txt` forbids `/wp-json/`. The run still succeeds, the row tells you which case it is, and nothing is charged for it.

**How are prices converted?** The Store API returns prices as strings in minor units. The Actor divides by 10 to the power of the shop's own `currency_minor_unit` (the number of decimals the shop is set up to show, usually 2), so `"3999"` becomes `39.99`. Empty prices come out as `null`.

**How fast is it, and is it polite?** About one request per second per shop, up to 100 products per request, with retries and back-off. The shop's `robots.txt` is obeyed. For example, a shop that disallows `/wp-json/` for all crawlers is skipped with a `blocked_by_robots` row.

**Does it collect personal data?** No. It saves product data only: names, SKUs, prices, stock, categories, images and rating numbers. Please check each shop's terms and the laws that apply to you before you reuse its data.

### Pricing

**$1.50 per 1,000 products** ($0.0015 per saved product row), pay per event. No start fee. Shop info rows and status rows are free. Example: a 500-product catalogue costs about $0.75. Platform usage is included in the price.

**Maximum items is a hard cap on charged rows.** Set `maxItems` in the run options (or `?maxItems=` in the API) and the run stops after that many products: it never writes or charges more rows than that number. Leave it empty for no cap. Free status rows are not counted.

Set a maximum charge per run to limit product charges. The Actor stops saving products when it reaches the event charge limit.

### Support and disclaimers

Questions and feature requests belong on the **Issues** tab of this Actor's page on Apify. This Actor is an independent tool and is not affiliated with WooCommerce, Automattic or the shops it reads. It reads only what a shop publishes through its public Store API; how you may use that data depends on the shop's terms and the applicable law.

Built and maintained by Atesen Software.

### Related actors

- [Shopify Scraper: Shopify Products, Prices, Variants & Stock](https://apify.com/atesen-software/shopify-store-products-scraper)
- [WordPress REST API Scraper: Export Posts & Pages to Markdown](https://apify.com/atesen-software/wordpress-posts-pages-exporter)
- [Tech Stack Detector: Website Technology Lookup, 3,600+ Techs](https://apify.com/atesen-software/website-tech-stack-detector)

# Actor input Schema

## `shops` (type: `array`):

Up to 50 public shop domains or HTTP(S) URLs, such as "mercantile.wordpress.org" or "https://example.com/shop/". The shop must expose its WooCommerce Store API on a standard web port.

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

Optional. Only products that match this text, like the shop's own search box.

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

Optional. Category slug, name or numeric ID. Separate several with commas. Products in any of them are kept.

## `maxItemsPerShop` (type: `integer`):

0 keeps paging until the shop ends the catalogue or the run reaches its budget or request limit.

## `includeDescriptions` (type: `boolean`):

Short and long product description as plain text.

## `includeShopInfo` (type: `boolean`):

One free row per shop: Store API address, currency, how many products matched and how many were saved.

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

How many different shops are read at the same time. Each single shop is still read at about one request per second.

## Actor input object example

```json
{
  "shops": [
    "mercantile.wordpress.org"
  ],
  "maxItemsPerShop": 100,
  "includeDescriptions": true,
  "includeShopInfo": true,
  "maxConcurrency": 2
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `allFields` (type: `string`):

No description

## `summary` (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 = {
    "shops": [
        "mercantile.wordpress.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("atesen-software/woocommerce-store-products-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 = { "shops": ["mercantile.wordpress.org"] }

# Run the Actor and wait for it to finish
run = client.actor("atesen-software/woocommerce-store-products-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 '{
  "shops": [
    "mercantile.wordpress.org"
  ]
}' |
apify call atesen-software/woocommerce-store-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,atesen-software/woocommerce-store-products-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/92uDEkxWRyXNJc58y/builds/1BufdVnxsfKZdHvKa/openapi.json
