WooCommerce Scraper - Category Sizes & Price Ranges

WooCommerce Scraper — Category Sizes, Price Ranges and Products

WooCommerce Scraper - Category Sizes & Price Ranges reads a store's public WooCommerce Store API and returns, for every product category, its product count, the store's own lowest and highest price for that set, the in-stock/out-of-stock/on-backorder split, the star-rating histogram and the attribute term counts — alongside the full product, category, tag, brand, attribute, review and WordPress content records. Unlike scraping frameworks that return raw HTML, this WooCommerce scraper returns typed JSON, ready for a database, a spreadsheet or an LLM context window without any parsing. No WooCommerce account, no API key and no cookie is required. This guide covers every input, every output field, and three ways teams put the category-level numbers to work.

🧭 What Does WooCommerce Scraper - Category Sizes & Price Ranges Do?

It reads a WooCommerce store's public /wp-json/wc/store/* Store API and the WordPress /wp-json/wp/v2/* REST API directly — the same endpoints WooCommerce's own shop filter widgets and theme pull from — and returns two kinds of rows: a category-summary row per product category, and a catalogue row per record the store publishes. No WooCommerce account, no API key, no consumer key/secret and no cookie is required to run it.

• Reads every category's collection summary — product count, price band, stock split, rating histogram and attribute term counts — from the store's own /products/collection-data endpoint
• Builds the subcategory tree, depth and root-to-leaf path from the category list already fetched, at no extra request cost
• Returns full product rows: pricing, stock, images, variations, attributes, add-to-cart rules
• Switches to categories, brands, tags, attributes or product reviews via a single Record type field
• Also reads the WordPress side of the same install: pages, posts, comments, post categories, post tags and users
• Expands variable products into their real variation records on request
• Escalates automatically from no proxy to an Apify datacenter proxy to an Apify residential proxy if a store blocks the direct request

⚡ Features & Capabilities

Everything below is either read straight from the store's own API responses or computed from numbers the store already published — nothing is averaged, scored or estimated by this Actor.

Core features

• Category size and price band, per category — product_count, min_price_value, max_price_value, price_spread_value, currency_code, built from the store's /products/collection-data response (capped at MAX_CATEGORY_LIST = 1,000 categories read per store)
• Stock and rating breakdown — stock_counts.in_stock / .out_of_stock / .on_backorder and rating_counts[] {rating, count} per category
• Attribute term counts with resolved names — attribute_counts[] {attribute, taxonomy, terms[] {term_id, term_name, count}}, built by joining the store's bare term IDs against its own attribute taxonomies (up to MAX_ATTRIBUTE_TAXONOMIES = 25 taxonomies looked up per store); an unresolved ID comes back with term_name: null, never a guessed name
• Subcategory tree — category_depth, category_path[], subcategories[] {category_id, name, product_count}, subcategory_count
• Full catalogue coverage — one Record type field switches between products, categories, brands, tags, attributes, reviews, pages, posts, comments, post-categories, post-tags and users
• Merge mode — set Record type to categories and the sizing fields land on the category record itself instead of producing a second row for the same category
• Product variations on request — expands each variable product's variations[] id list into real variation rows (up to limit × 20, capped at 500 lookups per store)
• Description formatting — description and short_description come back as Markdown, plain text or raw HTML

How WooCommerce Scraper - Category Sizes & Price Ranges compares to other WooCommerce scrapers

Observed on the Apify Store on 2026-08-16.

Feature	This Actor	WooCommerce Products Scraper — Full Store (trovevault)	WooCommerce Scraper (jupri)
Category-level price range & size summary	Yes, from /products/collection-data	Not offered	Not offered
Record types covered	12 (products, categories, brands, tags, attributes, reviews, pages, posts, comments, post-categories, post-tags, users)	Products only	Products, categories, brands, homepage content
Output format	Typed JSON	JSON, CSV or Excel	Markdown by default, customizable field transform
Proxy / anti-bot handling	3-tier automatic escalation (none → datacenter → residential) plus custom proxy support	Not stated on the listing	Proxy and custom header support (per listing)
Login / API key required	None	None	None
Pricing (per listing)	$0.003 per dataset row (pay per event)	$0.85 per 1,000 products	$3.00 per 1,000 results

If your use case is feeding structured data to an LLM, the output format row is the decision-maker — HTML parsing inside an agent loop is a reliability failure mode, not a feature. WooCommerce Scraper - Category Sizes & Price Ranges is not the only way to read a WooCommerce store; it is the one that also answers "how big is this category, and what does it cost" without you computing it from every product row yourself.

When another tool might suit you better

If all you need is a flat list of product rows at the lowest per-row price, with CSV/Excel export built in and no interest in category-level numbers, WooCommerce Products Scraper — Full Store is a leaner fit and genuinely cheaper per row. If you specifically need a store's brand taxonomy and homepage content pulled together with products in Markdown by default, WooCommerce Scraper (jupri) covers that combination directly. Neither of those trade-offs are wrong — they're just a different job than category sizing.

WooCommerce Scraper - Category Sizes & Price Ranges within the Scrapio data stack

Scrapio's WooCommerce coverage lives entirely in this one Actor: the Record type field already returns products, categories, brands, tags, attributes, reviews and the WordPress content types from the same run, so there's no second Scrapio WooCommerce scraper to route to for those. For a store built on Shopify instead of WooCommerce, see the Related Scrapers section below.

Why do developers and data teams scrape WooCommerce?

🏢 Retail merchandising and category planning teams

A merchandising analyst points this Actor at a competitor's or a partner's store domain with Record type set to categories, and gets back product_count, min_price_value / max_price_value and in_stock_count / out_of_stock_count for every category the store publishes. That table drops straight into a spreadsheet or BI tool for assortment-gap analysis — which categories a rival carries at real depth, and where their price band sits against your own.

📊 AI training data and RAG indexing

description and short_description (returned as Markdown, plain text or HTML) are the high-information text fields for RAG retrieval, and category_path[] plus attribute_counts[].terms[].term_name add the hierarchical and faceted context a retriever needs to answer "what's stocked here." For training data, the typed numeric and boolean fields — product_count, min_price_value, is_in_stock, average_rating — carry the same shape on every row, so no normalization step is needed before they hit a model.

📱 Competitive and market intelligence

Run this Actor on a schedule and track min_price_value, max_price_value and in_stock_count per category across runs. A category's price band widening, or its in_stock_count dropping while out_of_stock_count climbs, is a concrete, field-level signal of a competitor's pricing move or a supply problem — not a guess.

🔬 Research and academic use

Category depth, price dispersion and stock health across a list of WooCommerce stores make a reasonable public dataset for e-commerce market-structure research — everything here is data the store already publishes to any visitor's browser, and nothing else is read.

🎥 Product and SaaS development

The typed rows — price fields already converted to real currency units, stock booleans, the category tree — are a workable base for a pricing-monitoring feature, a catalogue-enrichment API or a directory product, without maintaining an in-house WooCommerce HTML scraper.

🍚 Input Parameters

All 35 fields below come straight from .actor/actor.json, in schema order. None is required — the run fails only if no store URL resolves from startUrls, url or dev_fileupload.

Parameter	Required	Type	Description	Example Value
startUrls	No	array	Store home pages, one per line. A bare domain works, and a sub-directory install is kept.	["https://porterandyork.com"]
url	No	array	Alternative to startUrls under the key url; both are read and duplicates removed.	["https://example.com/shop"]
dev_fileupload	No	string	URL of a text or JSON file holding one store URL per line, or a JSON array of URLs.	"https://example.com/stores.txt"
includeCategorySummary	No	boolean, default true	Read every category's collection summary: count, price band, stock split, rating histogram. One request and one charged row per category.	true
minCategoryProducts	No	integer, default 1, minimum 0	Drop categories holding fewer products than this. 0 keeps every category, including empty ones.	1
maxCategories	No	integer, default 50, min 1, max 500	Stop after this many category summaries per store, applied after ordering.	50
categoryOrder	No	string, default "size_desc"	How to order categories before the budget applies. Enum: size_desc (Most products first), size_asc (Fewest products first), name (Category name A-Z), store (The store's own order).	"size_desc"
includeSubcategories	No	boolean, default true	Add each category's direct children, depth and root-to-leaf path. No extra requests.	true
includeAttributeCounts	No	boolean, default true	Add attribute term counts, resolving bare term IDs to names via the store's taxonomies.	true
onlyCategoriesWithPrices	No	boolean, default false	Drop categories where the store publishes no price range.	false
resource	No	string, default "products"	Which catalogue records to return alongside the category summaries. Enum: products, categories, brands, tags, attributes, reviews, pages, posts, comments, post-categories, post-tags, users. categories merges the sizing fields onto the category rows instead of adding separate summary rows.	"products"
limit	No	integer, default 10, min 1, max 1000	Maximum catalogue records per store. Does not cap category summaries.	10
include_variations	No	boolean, default false	Also return every variation of the variable products found, up to limit × 20 lookups (capped at 500).	false
format	No	string, default "md"	Output format for descriptions. Enum: md (Markdown), text (Plain text), html (HTML).	"md"
sort	No	string, default "date"	Sort requested from the store for catalogue records. Enum: "" (Any), date, modified, id, include, title, slug, price, popularity, rating, menu_order, comment_count. An unsupported value for the chosen record type is logged and the store's own order is used.	"price"
order	No	string, default ""	Sort direction. Enum: "" (Auto), asc, desc. Applied only if the Sorting value is supported.	"desc"
search	No	string	Return only records matching this text. Not supported for attributes or reviews.	"beef"
category	No	string	Product category ID(s), comma separated, applied to catalogue records only.	"13,548"
sku	No	string	Return only products with this SKU. Products record type only.	"BF-001"
rating	No	string	Return only products rounding to this star rating. Enum: "" (Any), 1–5. Products record type only.	"5"
min_price	No	integer, minimum 0	Minimum price in the store's minor currency unit (cents). Products record type only.	1999
max_price	No	integer, minimum 0	Maximum price in the store's minor currency unit (cents). Products record type only.	4999
tag	No	string	Product tag ID(s), comma separated. Products record type only.	"42"
product_type	No	string	Enum: "" (Any), simple, grouped, external, variable, wbs_bundle, variation. Products record type only.	"variable"
stock	No	string	Enum: "" (Any), instock, outofstock, onbackorder. Products record type only.	"instock"
featured	No	boolean, default false	Return only featured products. Products record type only.	false
sale	No	boolean, default false	Return only products currently on sale. Products record type only.	false
proxyConfiguration	No	object	Apify proxy configuration. Escalates from none to datacenter to residential automatically if unset.	{"useApifyProxy": false}
dev_proxy_config	No	string	Your own HTTP(S) proxy, used instead of the Apify proxy. SOCKS is not supported.	"http://user:pass@proxy.example.com:8000"
dev_custom_headers	No	string	Extra HTTP headers as a JSON array of {name, value}, a JSON object, or one Name: value per line.	[{"name":"Authorization","value":"Bearer token"}]
dev_custom_cookies	No	string	Extra HTTP cookies, same accepted shapes as headers.	[{"name":"session","value":"abc123"}]
dev_transform_fields	No	string	Keep only these comma-separated field paths in the output; dot notation for nested fields, index for array elements.	"name,min_price_value,max_price_value"
dev_dataset_name	No	string	Write results to a named dataset instead of the default one. Supports {ACTOR}, {DATE}, {TIME} masks.	"sizes-{DATE}"
dev_dataset_clear	No	boolean, default false	Empty the named dataset before writing. No effect without dev_dataset_name.	false
dev_no_strip	No	boolean, default false	Keep null/empty values in the output so every row carries the same columns. Booleans and zeros are always kept.	false

Minimal — size up one store:

{
  "startUrls": ["https://porterandyork.com"],
  "includeCategorySummary": true,
  "minCategoryProducts": 1,
  "limit": 10
}

Sizing only, biggest categories first, no product rows:

{
  "startUrls": ["https://woocommerce.com"],
  "includeCategorySummary": true,
  "minCategoryProducts": 5,
  "maxCategories": 25,
  "categoryOrder": "size_desc",
  "includeSubcategories": true,
  "includeAttributeCounts": true,
  "onlyCategoriesWithPrices": true,
  "resource": "attributes",
  "limit": 1
}

Merge sizing fields onto the category records themselves:

{
  "startUrls": ["https://porterandyork.com"],
  "resource": "categories",
  "limit": 100,
  "includeCategorySummary": true
}

Supported URL types and input formats

startUrls accepts a bare domain (example.com), a full https:// URL, or a sub-directory WordPress install (https://example.com/shop), and both candidates are tried in that order so a pasted product URL still resolves to the store root. The same list can be supplied under the alternate key url, or appended to by pointing dev_fileupload at a plain-text file (one URL per line) or a JSON file — either a flat array of URLs, or an array of {"url": "..."} objects.

📦 Output Format

Every run writes typed JSON rows to the Apify dataset — one row per category summary, one row per catalogue record. The dataset ships two views: Everything scraped (both row types together) and Category sizes & price bands (the sizing columns only). From the Apify platform you can export either view as JSON, CSV, Excel, XML or RSS, or read it through the Dataset API.

Output for category

Every key build_category_summary_row() in main.py writes, with includeSubcategories and includeAttributeCounts both on:

{
  "row_type": "category-summary",
  "id": 13,
  "category_id": 13,
  "name": "Beef",
  "slug": "buy-beef-online",
  "parent": 0,
  "permalink": "https://porterandyork.com/product-category/buy-beef-online/",
  "url": "https://porterandyork.com/product-category/buy-beef-online/",
  "description": "",
  "image": null,
  "count": 23,
  "product_count": 23,
  "review_count": 0,
  "category_depth": 0,
  "category_path": ["Beef"],
  "category_path_slugs": ["buy-beef-online"],
  "parent_name": null,
  "subcategories": [
    { "category_id": 548, "name": "Steaks", "slug": "steak", "product_count": 14, "permalink": "https://porterandyork.com/product-category/steak/" }
  ],
  "subcategory_count": 1,
  "subcategory_product_count": 14,
  "summary_available": true,
  "summary_error": null,
  "price_range": { "currency_code": "USD", "currency_minor_unit": 0, "min_price": "13", "max_price": "745" },
  "price_range_available": true,
  "min_price_value": 13.0,
  "max_price_value": 745.0,
  "currency_code": "USD",
  "price_spread_value": 732.0,
  "stock_counts": { "in_stock": 21, "out_of_stock": 2, "on_backorder": 0 },
  "summary_product_count": 23,
  "in_stock_count": 21,
  "out_of_stock_count": 2,
  "rating_counts": [],
  "rated_product_count": 0,
  "attribute_counts": [
    {
      "attribute": "Size",
      "taxonomy": "pa_size",
      "attribute_id": 12,
      "terms": [{ "term_id": 263, "term_name": "12 oz, USDA Choice+", "term_slug": "12-oz-usda-choice", "count": 3 }],
      "term_count": 1
    }
  ],
  "attribute_counts_available": true,
  "attribute_term_names_resolved": true,
  "store": "https://porterandyork.com",
  "resource_type": "category-summary",
  "scraped_at": "2026-08-16T00:00:00Z"
}

summary_available: false and a non-null summary_error mean the store's /products/collection-data endpoint could not be read for that category — the row still carries the raw category record, with every summary field null rather than guessed.

Output for product

Every key transform_product() writes, when Record type is products (the default):

{
  "row_type": "products",
  "resource_type": "products",
  "url": "https://porterandyork.com/product/dry-aged-ribeye/",
  "id": 4821,
  "name": "Dry Aged Ribeye",
  "slug": "dry-aged-ribeye",
  "parent": 0,
  "type": "simple",
  "variation": false,
  "sku": "BF-118",
  "short_description": "USDA Choice, dry aged 28 days.",
  "description": "Full product description as Markdown, plain text or HTML.",
  "on_sale": false,
  "prices": {
    "price": "3900",
    "regular_price": "3900",
    "sale_price": "",
    "price_range": null,
    "currency_code": "USD",
    "currency_symbol": "$",
    "currency_minor_unit": 2,
    "currency_decimal_separator": ".",
    "currency_thousand_separator": ",",
    "currency_prefix": "$",
    "currency_suffix": ""
  },
  "price_value": 39.0,
  "regular_price_value": 39.0,
  "sale_price_value": null,
  "currency_code": "USD",
  "average_rating": "4.50",
  "review_count": 12,
  "images": [{ "id": 501, "src": "https://porterandyork.com/wp-content/uploads/ribeye.jpg" }],
  "categories": [{ "id": 13, "name": "Beef", "slug": "buy-beef-online" }],
  "tags": [],
  "brands": [],
  "attributes": [{ "id": 12, "name": "Size", "taxonomy": "pa_size", "terms": [{ "id": 263, "name": "12 oz" }] }],
  "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": { "text": "In stock", "class": "in-stock" },
  "add_to_cart": { "minimum": 1, "maximum": 0, "multiple_of": 1, "single_text": "Add to cart", "url": "" },
  "extensions": {},
  "store": "https://porterandyork.com",
  "scraped_at": "2026-08-16T00:00:00Z"
}

Output for other record types

For every other Record type value — categories (when not merging), brands, tags, attributes, reviews, pages, posts, comments, post-categories, post-tags, users — transform_data() returns the record exactly as WooCommerce's or WordPress's own endpoint publishes it, untouched, with four fields appended to every row: store, resource_type, row_type, scraped_at. Setting Record type to categories merges the category-summary fields above onto that same row instead of adding a second one, and the base category record's own values are never overwritten by the merge.

Schema stability and export options

Field names are fixed by this Actor's own code, not scraped from the page — they don't move when a store's theme or front end changes, only if the store's WooCommerce or WordPress REST API itself changes shape. A field the store doesn't send comes back null rather than being silently dropped or renamed, unless it's an empty string, array or object, which is stripped by default (turn on dev_no_strip to keep those too — booleans and zeros are always kept). Results live in an Apify dataset: the default dataset per run, or a named, reusable one via dev_dataset_name, exportable as JSON, CSV, Excel, XML or RSS from the Apify platform or read through the Dataset API.

💡 WooCommerce Scraper - Category Sizes & Price Ranges Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

A pricing or merchandising system needs a category's current size and price band the moment it's requested. Trigger a run via the Apify API with startUrls set to the target store and includeCategorySummary: true → the run reads /products/collection-data once per category → append min_price_value, max_price_value, product_count and in_stock_count / out_of_stock_count onto the matching category_id in your PIM or CRM record → write back through your own API. Prices arrive already converted to real currency units, so no post-processing step sits between the run and the write-back.

🎯 Strategy 2: Scheduled monitoring and alerting

Catch a competitor widening a category's price band or running low on stock. Attach an Apify Schedule to this Actor at whatever interval you need → diff this run's min_price_value, max_price_value and in_stock_count against the previous run's values for the same category_id → alert when the delta crosses your threshold. ⚠️ currency_code reflects the currency the store serves to the run's outbound IP address, not necessarily the merchant's base currency — compare runs made through the same proxy configuration, or a currency change will look like a price change.

🎯 Strategy 3: Bulk dataset build

Build a cross-store catalogue-sizing dataset for research or a training set. Put every store domain in startUrls, or upload a list via dev_fileupload → run once with resource: "categories" and a maxCategories budget sized to your coverage need → export the dataset to CSV, JSON or Excel from the Apify platform. Stores in a single run are read one after another, not in parallel, so split a large store list across several parallel runs to build a large dataset faster.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Appending live category numbers to a PIM/CRM record	On-demand run per lookup, via the Apify API	Typed JSON, read through the Dataset API
Scheduled monitoring	Tracking a competitor's price band and stock over time	Recurring run on an Apify Schedule, diffed against the last run	Typed JSON rows, compared by category_id
Bulk dataset build	Cross-store catalogue research or training data	One run per store list, or several parallel runs	Dataset export — JSON, CSV or Excel

🌴 Related WooCommerce Scrapers & Tools

Scrapio's WooCommerce coverage lives entirely in this one Actor — every catalogue record type is a Record type choice away, so there's no separate Scrapio WooCommerce scraper to route to. For a store built on Shopify instead of WooCommerce, these Scrapio scrapers cover comparable ground:

Scraper Name	What it extracts
Shopify Scraper: Related Products & Price Comparison	Shopify product listings with related-product and price-comparison data
Shopify Products Scraper — Descriptions, Specs & Tags	Shopify product descriptions, specs and tags
Shopify Store Scraper: Emails, Phones & Social Links	Shopify store contact and social details
Shopify Merchant Scraper: Market Currency & Shipping Data	Shopify merchant market, currency and shipping configuration

How to integrate WooCommerce Scraper - Category Sizes & Price Ranges with your stack

WooCommerce Scraper - Category Sizes & Price Ranges works with any language or tool that can make an HTTP request through the Apify API.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<APIFY_API_TOKEN>")
# replace with this Actor's own slug from its Apify Store page
actor_id = "scrapio/woocommerce-scraper-category-sizes-and-price-ranges"

stores = ["https://porterandyork.com", "https://woocommerce.com"]
rows = []

for store in stores:
    run = client.actor(actor_id).call(run_input={
        "startUrls": [store],
        "resource": "categories",
        "includeCategorySummary": True,
        "maxCategories": 50,
    })
    for item in client.dataset(run["defaultDatasetId"]).iterate_items():
        rows.append(item)

with open("category_sizes.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=sorted({k for r in rows for k in r}))
    writer.writeheader()
    writer.writerows(rows)

print(f"Wrote {len(rows)} rows for {len(stores)} store(s).")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_API_TOKEN>' });
// replace with this Actor's own slug from its Apify Store page
const actorId = 'scrapio/woocommerce-scraper-category-sizes-and-price-ranges';

const run = await client.actor(actorId).call({
  startUrls: ['https://porterandyork.com'],
  resource: 'categories',
  includeCategorySummary: true,
  maxCategories: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const category of items) {
  console.log(category.name, category.product_count, category.min_price_value, category.max_price_value);
}

Async and scheduled pipelines

Every run is asynchronous through the Apify API: start it, then poll the run's status or read the dataset once it finishes, rather than holding a connection open. For a recurring job, attach an Apify Schedule to this Actor instead of triggering it from your own cron, and set dev_dataset_name so every scheduled run lands in the same named dataset — useful for the diff-based monitoring pattern in Strategy 2 above.

🎯 Who Needs WooCommerce Scraper - Category Sizes & Price Ranges? (Use Cases & Industries)

🏢 Retail merchandising analysts

Pull a rival's product_count and min_price_value / max_price_value per category into a merchandising review before a planning meeting, and spot which categories they carry at real depth and which are thin.

📊 AI/ML and RAG teams

Index category_path, description and attribute_counts[].terms[].term_name into a vector store so an assistant can answer "what's in the Beef category and what does it cost" from typed fields, with no HTML to strip first.

📱 Competitive intelligence analysts

Schedule weekly runs against rival stores and alert when a category's min_price_value drops or its in_stock_count falls — a concrete field-level signal instead of a manual spot-check.

🔬 Researchers

Build a public dataset of category depth and price dispersion across many WooCommerce stores for market-structure research, using only data the stores already publish to any visitor.

🎥 Product and SaaS builders

Wrap this Actor's output in a pricing-monitoring or catalogue-enrichment feature built on typed JSON rows instead of maintaining an in-house WooCommerce scraper.

Is it legal to scrape WooCommerce stores?

Scraping publicly accessible storefront data is generally lawful in the United States. In hiQ Labs, Inc. v. LinkedIn Corp. (9th Cir. 2019, cert. denied 2022), the court held that scraping data a site makes available without a login does not violate the Computer Fraud and Abuse Act. WooCommerce Scraper - Category Sizes & Price Ranges reads only a store's own public /wp-json/wc/store/* and /wp-json/wp/v2/* endpoints — the same numbers a shopper's browser downloads to render the category page — with no login, no API key and no cookie.

Separately, a store's Terms of Service may restrict automated access; violating a ToS is a civil, contract-law matter between the scraper and the site operator, not a criminal one, and a site owner can still act on it — rate-limiting, blocking, or a breach-of-contract claim. This Actor returns business and catalogue data — category names, counts, prices, stock status — not personal data, so GDPR and similar data-protection regimes do not attach to the numbers it collects. The one exception is the reviews record type, which can carry a reviewer's public display name exactly as WooCommerce publishes it.

WooCommerce Scraper - Category Sizes & Price Ranges returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does WooCommerce Scraper - Category Sizes & Price Ranges work without a WooCommerce account?

Yes. It reads the store's public WooCommerce Store API and WordPress REST API directly; no login, no API key, no consumer key/secret and no cookie is required.

How does WooCommerce Scraper - Category Sizes & Price Ranges handle WooCommerce's anti-scraping measures?

It escalates through three proxy tiers automatically — no proxy, then an Apify datacenter proxy, then an Apify residential proxy — keeping whichever tier first answers 200 for the rest of that store's requests, and retries the residential tier up to 3 times before giving up. You can also supply your own HTTP(S) proxy, custom headers and custom cookies.

Can I run WooCommerce Scraper - Category Sizes & Price Ranges at scale without getting blocked?

There's no published uptime or block-rate figure. What the source code documents: stores within one run are read one after another, not in parallel, with each store getting its own independent proxy escalation; add throughput by running several parallel Actor runs against different store lists.

How fresh is the data WooCommerce Scraper - Category Sizes & Price Ranges returns?

It's a live fetch on every run — every field, including scraped_at, comes from the store's collection-data and catalogue endpoints at the moment the run executes. Nothing is cached or reused between runs.

What happens if a category publishes no price range?

The row still comes back, with price_range_available: false and null prices — never an invented 0. ⚠️ A genuinely free category looks different: a published minimum and maximum price of "0" comes back as 0.0, so "no price data" and "free" are never collapsed into the same value.

Which WooCommerce fields work best for AI training and RAG indexing?

For RAG, the high-information text fields are description and short_description (Markdown, plain text or HTML) plus category_path[] for hierarchical context. For training data, the typed numeric and boolean fields — product_count, min_price_value, is_in_stock, average_rating — carry a stable shape on every row, so no normalization step is needed before they reach a model or a vector store.

Does this Actor return personal data?

Almost never. Every field this Actor documents is store, category or product data — counts, prices, stock, ratings. The one exception is the reviews record type, which can include a reviewer's public display name exactly as WooCommerce publishes it; no email, phone or account credential is ever read. Lawful basis for storing and using that name sits with you.

Does WooCommerce Scraper - Category Sizes & Price Ranges work with Claude, ChatGPT and other AI agent tools?

It isn't published as an MCP server, so an agent framework calls it the same way any HTTP client would: through the Apify API's run and dataset endpoints. Every row is typed JSON, so an agent can read category or product fields straight into its context window without an HTML-parsing step first.

How does WooCommerce Scraper - Category Sizes & Price Ranges compare to other WooCommerce scrapers?

As observed on the Apify Store on 2026-08-16, WooCommerce Products Scraper — Full Store (trovevault) is a strong choice if you only need flat per-product rows at a lower per-row price and don't need category-level numbers; WooCommerce Scraper (jupri) covers products, categories, brands and homepage content in Markdown by default. Neither listing describes a per-category price range, stock split or attribute-count summary — that collection-data layer, and the merged categories resource mode, is what this Actor adds on top of comparable catalogue coverage.

ℹ️ Disclaimer

WooCommerce Scraper - Category Sizes & Price Ranges extracts only publicly available data from WooCommerce-powered stores. This tool is intended for lawful use cases only. Users are responsible for complying with each target store's terms of service and applicable data protection laws in their jurisdiction.