# REI Product Scraper (`crawlerbros/rei-product-scraper`) Actor

Scrape live outdoor gear, apparel, and footwear listings from REI.com - search by keyword, browse by category or brand, or look up full product detail (price, member price, rating, images) by URL. No login required.

- **URL**: https://apify.com/crawlerbros/rei-product-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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

## REI Product Scraper

Scrape **REI.com** — live outdoor gear, apparel, and footwear listings from REI Co-op. Search by keyword, browse by category or filter by brand within a category, or look up a specific product by URL. No login required.

### What this actor does

- **Four modes:** `search`, `browseByCategory`, `browseByBrand`, `productDetail`
- **125+ category shortcuts** across hiking, camping, climbing, cycling, water sports, snow sports, running, footwear, and apparel — plus a free-text override for any of REI's 400+ category slugs
- **Filters:** price range, minimum rating, on-sale-only (includes clearance/outlet), gender (real server-side REI facet)
- **Sort:** 10 options — relevance, price (low/high), rating, most reviewed, newest, bestselling, biggest % off, brand A-Z/Z-A — most are REI's own server-side sort, so results reflect the true order/cheapest/newest across the whole category, not just whichever pages were fetched
- **Advanced facet passthrough** (`additionalFacets`) for category-specific filters REI exposes in its sidebar — features, best-use, sustainability certifications, and more
- **Available colors, rating, review count, and description** on every product
- **Empty fields are omitted**

#### Gender filter fix (2026-07)

`gender` is now wired into REI's real server-side `r=gender:<value>` facet (confirmed live: filtering `hiking-boots` by `Women's` genuinely drops the category's total page count roughly in half, and every returned title matches). Previously this filter only checked a raw JSON field that is blank on almost every REI listing, so it was a near-total no-op — selecting "Men's" silently returned unfiltered results. A client-side check is still kept as a harmless safety net, but the server-side facet is now the real mechanism.

### Output per product

- `prodId` — REI's numeric product identifier
- `productName`, `brandName`
- `price` — current selling price (USD)
- `originalPrice`, `percentOff`, `onSale`
- `clearance`, `outlet` — REI Outlet / clearance flags
- `averageRating` (1–5), `reviewCount`
- `gender` (when the product is gender-specific)
- `color`, `availableColors[]`
- `description`
- `inStock`
- `imageUrl`
- `productUrl`
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `browseByCategory` / `browseByBrand` / `productDetail` |
| `searchQuery` | string | `hiking boots` | Free-text keyword search (mode=search) |
| `category` | string | `hiking-boots` | Category to browse (mode=browseByCategory, browseByBrand) |
| `categoryOther` | string | – | Custom category slug when `category` = "Other" |
| `brand` | string | `Patagonia` | Brand to filter by within the category (mode=browseByBrand) |
| `productUrls` | array | – | REI product page URLs (mode=productDetail) |
| `gender` | string | `Any` | Men's / Women's / Boys' / Girls' / Kids' / Unisex |
| `minPrice` / `maxPrice` | int | – | Price range in USD |
| `minRating` | int | – | Drop products rated below this (1–5) |
| `onSaleOnly` | bool | `false` | Only emit discounted/clearance/outlet products |
| `sortBy` | string | `relevance` | Result sort order — see "Sort options" below |
| `additionalFacets` | array | `[]` | Advanced: raw REI `facetKey:value` strings, e.g. `features:Waterproof` — see "Advanced facets" below |
| `maxItems` | int | `20` | Hard cap (1–300) |

#### Sort options

| `sortBy` value | REI server key | Mechanism |
|---|---|---|
| `relevance` | *(default, no param)* | Server |
| `priceLowToHigh` | `min-price` | Server |
| `priceHighToLow` | `max-price` | Server |
| `ratingHighToLow` | `rating\|num-reviews` | Server (rating desc, review count as tiebreaker) |
| `mostReviewed` | *(none confirmed)* | Client-side re-sort of fetched pages only |
| `newest` | `days-old` | Server |
| `bestselling` | `sc_revenue` | Server |
| `percentOff` | `percentageoff` | Server |
| `brandAtoZ` | `title` | Server |
| `brandZtoA` | `title_r` | Server |

All server-backed options fetch pages already in that true order across the whole category. `mostReviewed` has no confirmed direct REI sort key — REI's closest key (`rating|num-reviews`) sorts by rating first and review count only as a tiebreaker, so it isn't a true "most reviewed" order; `mostReviewed` stays a re-sort of whatever pages were fetched, same limitation every sort option used to have.

#### Advanced facets (`additionalFacets`)

REI's category pages expose extra sidebar filters that are genuinely category-specific (hiking boots and tents don't share the same filter set), so instead of a fixed dropdown, pass raw `facetKey:value` strings. **Values are case-sensitive and must match REI's displayed filter label exactly** (Title Case, spaces not hyphens) — `features:waterproof` returns nothing; `features:Waterproof` works.

Confirmed-real examples:

| Category | Facet entries |
|---|---|
| `hiking-boots` | `features:Waterproof`, `features:Vegan`, `features:Top Rated`, `features:Insulated`, `features:New Arrivals`, `best-use:Hiking`, `best-use:Backpacking`, `best-use:Trail Running`, `sustainability:bluesign` (lowercase — intentional), `sustainability:Recycled Materials` |
| `tents` | `features:Ultralight` |

Multiple facets (including `brand` and `gender`) all combine correctly in the same request — pass as many `additionalFacets` entries as you like. Works for `search`, `browseByCategory`, and `browseByBrand`; ignored for `productDetail` (a single product lookup should not be excluded by a facet).

#### Example: search with price and rating filters

```json
{
  "mode": "search",
  "searchQuery": "2-person tent",
  "minPrice": 100,
  "maxPrice": 400,
  "minRating": 4,
  "maxItems": 30
}
````

#### Example: browse a category, on sale only

```json
{
  "mode": "browseByCategory",
  "category": "backpacking-packs",
  "onSaleOnly": true,
  "sortBy": "priceLowToHigh",
  "maxItems": 50
}
```

#### Example: browse a brand within a category

```json
{
  "mode": "browseByBrand",
  "category": "mens-jackets",
  "brand": "Patagonia",
  "maxItems": 30
}
```

#### Example: product detail by URL

```json
{
  "mode": "productDetail",
  "productUrls": [
    "https://www.rei.com/product/237486/merrell-moab-3-mid-waterproof-hiking-boots-womens"
  ]
}
```

#### Example: women's hiking boots, newest first, waterproof only

```json
{
  "mode": "browseByCategory",
  "category": "hiking-boots",
  "gender": "Women's",
  "sortBy": "newest",
  "additionalFacets": ["features:Waterproof"],
  "maxItems": 30
}
```

#### Example: bestselling Patagonia men's jackets

```json
{
  "mode": "browseByBrand",
  "category": "mens-jackets",
  "brand": "Patagonia",
  "gender": "Men's",
  "sortBy": "bestselling",
  "maxItems": 30
}
```

### Use cases

- **Price monitoring** — track REI sale, clearance, and outlet pricing over time
- **Assortment research** — see which brands dominate each outdoor activity category
- **Competitive intelligence** — compare gear pricing/ratings against other outdoor retailers
- **Review analytics** — pull rating and review-count trends by brand or category
- **Gear guides** — build "best hiking boots" or "best tents" content from live REI listings

### FAQ

**Is this affiliated with REI?** No — this is an independent, third-party actor that reads REI's public website. It is not endorsed by or affiliated with Recreational Equipment, Inc. (REI Co-op).

**Do I need an REI account or cookies?** No. All modes work against publicly browsable pages — no login required.

**Why does `browseByBrand` require a category?** REI does not publish a brand-wide catalog page — brand pages (e.g. `rei.com/b/patagonia`) are marketing landing pages without a product grid. Brand filtering only works scoped to a category (e.g. "Patagonia jackets"), which mirrors how REI's own site filters work.

**Why is the category list a dropdown of ~125 options instead of all of REI's categories?** REI has 400+ category slugs. The dropdown covers the most popular ones across every major activity; pick "Other" and type any valid slug from a `rei.com/c/<slug>` URL to reach the rest.

**How does keyword `search` work if there's no dedicated search field in the results?** `search` matches your query against REI's own category taxonomy (e.g. "waterproof hiking boots" routes to the `hiking-boots` category) and applies REI's in-category keyword filter on top. This returns highly relevant, always-live results without depending on REI's separate search page. If your query doesn't map well to any category, try `browseByCategory` directly with the closest category from the dropdown.

**How does `productDetail` resolve a URL?** The actor extracts the product ID and descriptive words from the URL slug, routes them through the same category-matching logic as `search`, and returns the matching product record. If REI has since delisted the product or moved it to a category the matcher can't infer from the URL slug, the run reports 0 results for that URL — no data is ever fabricated.

**What counts as "on sale"?** Any product marked sale, clearance, or outlet by REI, or where the current price is below the regular/compare-at price.

**How fresh is the data?** Real-time — every run loads the live REI page.

**Why do `productUrl`/`imageUrl` sometimes fail to load in a script or `curl` but work fine in my browser?** REI's anti-bot system blocks automated, non-browser requests specifically on `/product/*` and image-CDN paths (it does not block `/c/<category>` browsing). A normal person clicking the link in a real browser — from search results, a shared link, etc. — loads it without any issue. Only scripted `curl`/`fetch`-style requests to those two specific path types are affected.

**Can I get REI Co-op member pricing?** No — member-only pricing requires a logged-in REI Co-op account. The actor returns REI's publicly displayed price.

**Why do `additionalFacets` values need exact capitalization?** REI's facet filter matches the exact text shown in its own sidebar (e.g. "Waterproof", "Top Rated"), not the lowercase-hyphenated URL slug REI uses internally for the same option — a lowercase or hyphenated guess returns REI's 404 page instead of filtered results. Open the category on rei.com, check the filter sidebar for the exact label, and use that.

**Does `gender` combine correctly with `brand` and `additionalFacets`?** Yes — all REI facets you set (brand, gender, additionalFacets) are combined into a single request and are confirmed live to genuinely narrow the result set together (e.g. Merrell + Women's + Waterproof returns only matching boots, not just one of the three filters).

# Actor input Schema

## `mode` (type: `string`):

What to fetch from REI.

## `searchQuery` (type: `string`):

Free-text keyword search, e.g. `hiking boots`, `2-person tent`, `Patagonia jacket`.

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

REI activity/product category to browse. Choose "Other (type below)" to enter any of REI's 400+ category slugs not listed here.

## `categoryOther` (type: `string`):

Any REI category slug not in the dropdown, e.g. `avalanche-safety-gear`, `bivy-sacks`, `camp-hydration`. Find the slug in a REI category page URL: rei.com/c/<slug>.

## `brand` (type: `string`):

Brand name to filter the selected category by, e.g. `Patagonia`, `Merrell`, `The North Face`, `Osprey`. REI does not offer a brand-wide catalog page, so brand browsing is scoped to a category.

## `productUrls` (type: `array`):

REI product page URLs, e.g. `https://www.rei.com/product/237486/merrell-moab-3-mid-waterproof-hiking-boots-womens`.

## `gender` (type: `string`):

Restrict results to a gender/age category. Applied server-side via REI's own `r=gender:<value>` facet (confirmed live to genuinely change the returned product set, e.g. men's vs. women's boots), not just a post-fetch filter — so this also reduces how many pages need to be fetched. Ignored for mode=productDetail (a single product lookup should not be excluded by a facet).

## `minPrice` (type: `integer`):

Drop products cheaper than this.

## `maxPrice` (type: `integer`):

Drop products pricier than this.

## `minRating` (type: `integer`):

Drop products rated below this.

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

Only emit products currently discounted below the regular price (includes clearance and outlet).

## `sortBy` (type: `string`):

Result sort order. Most options map to REI's own server-side `sort=` parameter (confirmed live), so REI returns pages already in that order across the whole category — not just a re-shuffle of whatever pages happened to be fetched. Exception: "Most reviewed" has no confirmed direct REI server key, so it stays a client-side re-sort of the fetched pages only.

## `additionalFacets` (type: `array`):

Raw REI category facets as `facetKey:value` strings, appended to the category fetch on top of any brand/gender filters (works for Search, Browse by category, and Browse by brand; ignored for Product detail). REI's facet set is genuinely category-specific (hiking boots and tents expose different facets) so this is free text rather than a dropdown — use REI's own category filter sidebar to discover more. IMPORTANT: values are case-sensitive and must match REI's displayed filter label exactly (Title Case, spaces not hyphens) — `features:waterproof` returns nothing, `features:Waterproof` works. Confirmed-real examples: `features:Waterproof`, `features:Vegan`, `features:Top Rated`, `features:Insulated`, `features:New Arrivals` (hiking-boots); `features:Ultralight` (tents); `best-use:Hiking`, `best-use:Backpacking`, `best-use:Trail Running` (hiking-boots); `sustainability:bluesign` (lowercase — intentional), `sustainability:Recycled Materials`.

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

Hard cap on emitted records.

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

Optional Apify proxy. The actor does not require a proxy for normal operation; you can enable the free Datacenter (AUTO) group if you see blocked runs.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "hiking boots",
  "category": "hiking-boots",
  "brand": "Patagonia",
  "productUrls": [],
  "gender": "Any",
  "onSaleOnly": false,
  "sortBy": "relevance",
  "additionalFacets": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset containing all scraped REI products.

# 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 = {
    "mode": "search",
    "searchQuery": "hiking boots",
    "category": "hiking-boots",
    "brand": "Patagonia",
    "productUrls": [],
    "gender": "Any",
    "onSaleOnly": false,
    "sortBy": "relevance",
    "additionalFacets": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/rei-product-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 = {
    "mode": "search",
    "searchQuery": "hiking boots",
    "category": "hiking-boots",
    "brand": "Patagonia",
    "productUrls": [],
    "gender": "Any",
    "onSaleOnly": False,
    "sortBy": "relevance",
    "additionalFacets": [],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/rei-product-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 '{
  "mode": "search",
  "searchQuery": "hiking boots",
  "category": "hiking-boots",
  "brand": "Patagonia",
  "productUrls": [],
  "gender": "Any",
  "onSaleOnly": false,
  "sortBy": "relevance",
  "additionalFacets": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call crawlerbros/rei-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "REI Product Scraper",
        "description": "Scrape live outdoor gear, apparel, and footwear listings from REI.com - search by keyword, browse by category or brand, or look up full product detail (price, member price, rating, images) by URL. No login required.",
        "version": "1.0",
        "x-build-id": "uJd8eheEOwmb1RuvS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~rei-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-rei-product-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/crawlerbros~rei-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-rei-product-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/crawlerbros~rei-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-rei-product-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "browseByCategory",
                            "browseByBrand",
                            "productDetail"
                        ],
                        "type": "string",
                        "description": "What to fetch from REI.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text keyword search, e.g. `hiking boots`, `2-person tent`, `Patagonia jacket`.",
                        "default": "hiking boots"
                    },
                    "category": {
                        "title": "Category (mode=browseByCategory, browseByBrand)",
                        "enum": [
                            "Other",
                            "hiking-boots",
                            "winter-hiking-boots",
                            "hiking-backpacks",
                            "hiking-jackets",
                            "hiking-pants",
                            "hiking-shirts",
                            "hiking-shorts",
                            "hiking-socks",
                            "trekking-poles-hiking-staffs",
                            "backpacking-tents",
                            "backpacking-packs",
                            "camping-tents",
                            "tents",
                            "sleeping-bags",
                            "sleeping-pads",
                            "camp-kitchen",
                            "camp-furniture",
                            "camp-chairs",
                            "coolers",
                            "headlamps",
                            "lanterns",
                            "water-bottles",
                            "portable-water-treatment",
                            "climbing-shoes",
                            "climbing-harnesses",
                            "climbing-ropes",
                            "climbing-helmets",
                            "carabiners",
                            "chalk-and-chalk-bags",
                            "bouldering-crash-pads",
                            "climbing-hardware",
                            "climbing-packs",
                            "mountaineering-boots",
                            "mountaineering-tents",
                            "crampons",
                            "ice-axes-and-tools",
                            "bikes",
                            "mountain-bikes",
                            "road-bike-helmets",
                            "bike-helmets",
                            "cycling-shoes",
                            "cycling-clothing",
                            "electric-bikes",
                            "gravel-bikes",
                            "hybrid-bikes",
                            "cruiser-bikes",
                            "bike-accessories",
                            "bike-locks",
                            "bike-lights",
                            "kayaks",
                            "kayaking",
                            "paddleboards",
                            "paddleboarding",
                            "wetsuits",
                            "dry-bags",
                            "pfds",
                            "kayak-paddles",
                            "paddleboard-paddles",
                            "dry-suits",
                            "downhill-skis",
                            "downhill-ski-boots",
                            "backcountry-skis",
                            "cross-country-skis",
                            "snowboards",
                            "snowboard-boots",
                            "snowboard-bindings",
                            "ski-helmets",
                            "ski-goggles",
                            "snowshoes",
                            "snowshoeing",
                            "splitboards",
                            "snow-jackets",
                            "snow-pants",
                            "mens-running-shoes",
                            "womens-running-shoes",
                            "mens-trail-running-shoes",
                            "womens-trail-running-shoes",
                            "running-packs",
                            "running-hydration-vests",
                            "mens-hiking-shoes",
                            "womens-hiking-shoes",
                            "mens-boots",
                            "womens-boots",
                            "mens-sandals",
                            "womens-sandals",
                            "kids-shoes",
                            "kids-boots",
                            "mens-jackets",
                            "womens-jackets",
                            "mens-rain-jackets",
                            "womens-rain-jackets",
                            "mens-insulated-jackets",
                            "womens-insulated-jackets",
                            "mens-fleece-and-soft-shell-jackets",
                            "womens-fleece-and-soft-shell-jackets",
                            "base-layers",
                            "mens-pants",
                            "womens-pants",
                            "mens-shorts",
                            "womens-shorts",
                            "mens-swimwear",
                            "womens-swimwear",
                            "mens-gloves-and-mittens",
                            "womens-gloves-and-mittens",
                            "sun-hats",
                            "sunglasses",
                            "backpacks",
                            "travel-backpacks",
                            "duffel-bags",
                            "day-packs",
                            "travel-daypacks",
                            "kids-clothing",
                            "kids-backpacks",
                            "kids-bikes",
                            "kids-sleeping-bags",
                            "gps",
                            "gps-sports-watches",
                            "binoculars-and-optics",
                            "satellite-communicators",
                            "solar-chargers",
                            "watches",
                            "first-aid",
                            "socks",
                            "dog-gear"
                        ],
                        "type": "string",
                        "description": "REI activity/product category to browse. Choose \"Other (type below)\" to enter any of REI's 400+ category slugs not listed here.",
                        "default": "hiking-boots"
                    },
                    "categoryOther": {
                        "title": "Custom category slug (used when Category = \"Other\")",
                        "type": "string",
                        "description": "Any REI category slug not in the dropdown, e.g. `avalanche-safety-gear`, `bivy-sacks`, `camp-hydration`. Find the slug in a REI category page URL: rei.com/c/<slug>."
                    },
                    "brand": {
                        "title": "Brand (mode=browseByBrand)",
                        "type": "string",
                        "description": "Brand name to filter the selected category by, e.g. `Patagonia`, `Merrell`, `The North Face`, `Osprey`. REI does not offer a brand-wide catalog page, so brand browsing is scoped to a category.",
                        "default": "Patagonia"
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=productDetail)",
                        "type": "array",
                        "description": "REI product page URLs, e.g. `https://www.rei.com/product/237486/merrell-moab-3-mid-waterproof-hiking-boots-womens`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "gender": {
                        "title": "Gender filter",
                        "enum": [
                            "Any",
                            "Men's",
                            "Women's",
                            "Boys'",
                            "Girls'",
                            "Kids'",
                            "Unisex"
                        ],
                        "type": "string",
                        "description": "Restrict results to a gender/age category. Applied server-side via REI's own `r=gender:<value>` facet (confirmed live to genuinely change the returned product set, e.g. men's vs. women's boots), not just a post-fetch filter — so this also reduces how many pages need to be fetched. Ignored for mode=productDetail (a single product lookup should not be excluded by a facet).",
                        "default": "Any"
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop products cheaper than this."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop products pricier than this."
                    },
                    "minRating": {
                        "title": "Min average rating (1-5)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop products rated below this."
                    },
                    "onSaleOnly": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Only emit products currently discounted below the regular price (includes clearance and outlet).",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "priceLowToHigh",
                            "priceHighToLow",
                            "ratingHighToLow",
                            "mostReviewed",
                            "newest",
                            "bestselling",
                            "percentOff",
                            "brandAtoZ",
                            "brandZtoA"
                        ],
                        "type": "string",
                        "description": "Result sort order. Most options map to REI's own server-side `sort=` parameter (confirmed live), so REI returns pages already in that order across the whole category — not just a re-shuffle of whatever pages happened to be fetched. Exception: \"Most reviewed\" has no confirmed direct REI server key, so it stays a client-side re-sort of the fetched pages only.",
                        "default": "relevance"
                    },
                    "additionalFacets": {
                        "title": "Additional REI facets (advanced)",
                        "type": "array",
                        "description": "Raw REI category facets as `facetKey:value` strings, appended to the category fetch on top of any brand/gender filters (works for Search, Browse by category, and Browse by brand; ignored for Product detail). REI's facet set is genuinely category-specific (hiking boots and tents expose different facets) so this is free text rather than a dropdown — use REI's own category filter sidebar to discover more. IMPORTANT: values are case-sensitive and must match REI's displayed filter label exactly (Title Case, spaces not hyphens) — `features:waterproof` returns nothing, `features:Waterproof` works. Confirmed-real examples: `features:Waterproof`, `features:Vegan`, `features:Top Rated`, `features:Insulated`, `features:New Arrivals` (hiking-boots); `features:Ultralight` (tents); `best-use:Hiking`, `best-use:Backpacking`, `best-use:Trail Running` (hiking-boots); `sustainability:bluesign` (lowercase — intentional), `sustainability:Recycled Materials`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy. The actor does not require a proxy for normal operation; you can enable the free Datacenter (AUTO) group if you see blocked runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
