# WooCommerce Catalog Radar (`rickbackend/woocommerce-catalog-radar`) Actor

Export public WooCommerce product prices and stock availability. Compare snapshots by product ID, preserving currencies and price ranges. Up to 100 products per run; no login, browser or LLM required.

- **URL**: https://apify.com/rickbackend/woocommerce-catalog-radar.md
- **Developed by:** [Ricardo Silva](https://apify.com/rickbackend) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 product snapshots

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

# README

### What does WooCommerce Catalog Radar do?

Export prices and stock availability from a public WooCommerce Store API. Optionally compare the result with a previous snapshot to identify price changes and stock transitions for the same product IDs.

Use it to check a supplier's selected products, prepare a price comparison spreadsheet, or feed catalog observations into your own backend. Apify provides API access, dataset exports, scheduling and integrations; previous snapshots must be passed explicitly between runs.

### How to use it

1. Enter the public Store API URL in the Input tab. The WordPress merchandise endpoint below is a working technical example.
2. Choose 1–100 products and start a run.
3. Download the dataset as JSON, CSV or Excel. Save the OUTPUT JSON if you want to compare a later observation.
4. For the next run, paste that JSON into `previousSnapshot` and use the same URL and filters.

### Input

```json
{
  "apiUrl": "https://mercantile.wordpress.org/wp-json/wc/store/v1/products",
  "maxProducts": 8
}
```

Use `?include=123,456` to follow specific product IDs. The API must be publicly accessible without login or API keys. Each run requests at most 100 products with bounded pagination. It does not scrape arbitrary web pages or bypass access restrictions.

### Results

The default dataset contains one row per observed product and can be exported using Apify's dataset export options. Each row contains product ID, SKU, name, product link, integer minor-unit prices, currency, currency unit, price type, stock availability, observation time, comparison status and a list of changes.

For example, `price_minor: 2600`, `currency: "BRL"`, `currency_minor_unit: 2` means BRL 26.00. Variable products may have a price range. Unknown values remain null. Stock availability does not indicate inventory quantity. Prices depend on the source and may vary by location; shipping and taxes are not included.

The default key-value store's `OUTPUT` record contains the snapshot and a summary. To compare two runs, copy the earlier OUTPUT JSON into the next run's `previousSnapshot` input, keeping the same API URL and filters. No previous customer run is looked up automatically. Without this input, all rows are marked `baseline` and no changes are reported.

Missing products are reported in `notSeenProductIds`, without claiming deletion or unavailability. A newly observed ID is marked `not_in_previous_sample`, without claiming the source just added the product. Currency and decimal-unit changes are separate from price changes. HTTP 401, 403 or 429 stops the run. Source failures do not produce a successful partial snapshot.

| Field | Meaning |
| --- | --- |
| `product_id`, `sku`, `name`, `url` | Product identity and source link |
| `price_minor`, `price_max_minor` | Price or range in integer minor units |
| `currency`, `currency_minor_unit` | Currency code and decimal places |
| `in_stock` | Availability, or null if unknown |
| `comparison_status`, `changes` | Comparison with your supplied snapshot |

Illustrative output fields (not a live price):

```json
{"product_id":"123","sku":"EXAMPLE","price_minor":2600,"currency":"BRL","currency_minor_unit":2,"in_stock":true,"comparison_status":"baseline","changes":[]}
```

### Pricing

The pilot price is **US$1 per 1,000 saved product snapshots** (US$0.001 each), plus **US$0.00005 per Actor start** at the supported 128–256 MB memory. Platform usage is included for customers running the published Actor. A run saving 8 products costs US$0.00805; 100 products cost US$0.10005. Each observation is charged, including unchanged products. The start event can still apply if the source is empty or a run fails.

Consult the live Pricing tab for the authoritative current price. Set a maximum cost per run; if it limits dataset delivery, OUTPUT includes only the delivered rows, marks `truncatedByChargeLimit`, and does not report missing IDs from that truncated sample. If the platform stops a run before OUTPUT is saved, use the already saved dataset rows.

### Scope and current status

This is an early pilot, limited to the public WooCommerce Store API v1. The WordPress merchandise store is a technical example, not a recommended supplier or a resale opportunity. This Actor is not affiliated with WooCommerce or WordPress.

One run collects one snapshot and exits. Scheduling, downstream delivery and forwarding the previous snapshot must be configured separately. No email or messaging service is included. Use public endpoints you are authorized to access and respect the source's terms. For errors, supported-source questions or a custom workflow request, open an [Issue](https://apify.com/rickbackend/woocommerce-catalog-radar/issues).

# Actor input Schema

## `apiUrl` (type: `string`):

Public endpoint ending in /wp-json/wc/store/v1/products. No login or API keys. Add ?include=123,456 to track fixed product IDs.

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

Bounded sample of 1–100 products. This does not guarantee a complete catalog.

## `previousSnapshot` (type: `object`):

Paste the OUTPUT JSON from an earlier run with the same API URL and filters. Without it, this run establishes a baseline. No shared history is read automatically.

## Actor input object example

```json
{
  "apiUrl": "https://mercantile.wordpress.org/wp-json/wc/store/v1/products",
  "maxProducts": 8
}
```

# Actor output Schema

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

No description

## `snapshot` (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 = {
    "apiUrl": "https://mercantile.wordpress.org/wp-json/wc/store/v1/products",
    "maxProducts": 8
};

// Run the Actor and wait for it to finish
const run = await client.actor("rickbackend/woocommerce-catalog-radar").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 = {
    "apiUrl": "https://mercantile.wordpress.org/wp-json/wc/store/v1/products",
    "maxProducts": 8,
}

# Run the Actor and wait for it to finish
run = client.actor("rickbackend/woocommerce-catalog-radar").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 '{
  "apiUrl": "https://mercantile.wordpress.org/wp-json/wc/store/v1/products",
  "maxProducts": 8
}' |
apify call rickbackend/woocommerce-catalog-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rickbackend/woocommerce-catalog-radar"
        }
    }
}
```

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/xFX82n61LOa3175md/builds/iLKCN3uNlVAU7IhAQ/openapi.json