# Casper Scraper (`crawlerbros/casper-scraper`) Actor

Scrape Casper.com mattresses, pillows, bedding, bed frames & furniture. Browse by category, search by keyword, or look up exact products by handle/URL. Full pricing (incl. sale pricing), variants, images, descriptions, and Yotpo review ratings. No auth, no proxy.

- **URL**: https://apify.com/crawlerbros/casper-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Casper Scraper

Scrape **Casper.com** — mattresses, pillows, bedding, bed frames, adjustable bases, headboards, furniture and accessories. Browse by category, search by keyword, look up exact products by handle or URL, or pull customer reviews. Get full pricing per size/color variant (including sale pricing when the retailer sets it), product images, descriptions, stock status, and Yotpo review ratings — down to individual review text. HTTP-only via Casper's public storefront JSON API. No auth, no proxy, no cookies.

### What this actor does

- **Four modes:** `category` (browse), `search` (keyword), `product` (exact lookup by handle or URL), `reviews` (individual customer reviews for a product)
- **28 curated categories:** mattresses, pillows, bedding, sheets, duvets, bed frames, adjustable bases, headboards, furniture, accessories, clearance, best sellers, and more
- **Full variant pricing:** every size/color option (Twin, Queen, King, Indigo, Olive, etc.) with price, sale price when applicable, stock status and a variant-specific photo when Casper sets one
- **Review ratings & reviews:** average star rating, total review count and star-rating breakdown per product, plus individual review text/rating/author/date via `mode=reviews`
- **Client-side sorting:** by price, title, rating, or newest — on top of Casper's own default ranking
- **Filters:** price range, size, color, in-stock only
- **Empty fields are omitted** — a field only appears on a record when real data was found for it

### Output per product (`category` / `search` / `product` modes)

- `handle` — Casper product handle (URL slug)
- `productId` — Shopify product ID
- `title`, `description` — product name and plain-text description
- `vendor` — always `Casper`
- `productType` — e.g. `Mattress`, `Pillows`, `Bedding`
- `tags[]` — internal Casper product tags (useful for cross-referencing model lines)
- `optionNames[]` — variant option names, e.g. `["Size"]` or `["Size", "Color"]`
- `variants[]` — one entry per purchasable size/color, each with:
  - `variantId`, `title` (e.g. `Queen`), `price`
  - `size`, `color` — the variant's own size/color values, when the product has that option axis
  - `compareAtPrice`, `onSale`, `discountPercent` — only present when the variant is genuinely discounted
  - `sku`, `barcode`, `available`, `weight`, `weightUnit`
  - `imageUrl` — the variant/color-specific product photo, when Casper sets one distinct from the main gallery
- `priceMin`, `priceMax` — lowest/highest variant price on the product
- `onSale`, `maxDiscountPercent` — present when at least one variant is discounted
- `inStock` — true if at least one size/color variant is currently purchasable
- `imageUrls[]`, `imageUrl` — all product image URLs, plus the first as a convenience field
- `productUrl` — canonical `casper.com/products/...` page
- `createdAt`, `updatedAt` — when the product was added to / last updated in Casper's catalog
- `averageRating`, `totalReviews`, `starDistribution` — from Casper's Yotpo review widget: overall rating, review count, and a `{"1":count, ..., "5":count}` breakdown (only when Casper has published reviews for the product; distribution omits star levels with zero reviews)
- `recordType: "product"`, `scrapedAt`

### Output per review (`reviews` mode)

- `reviewId` — Yotpo review ID
- `productHandle`, `productTitle`, `productUrl` — the product the review belongs to
- `rating` — 1–5 star rating given by the reviewer
- `title`, `content` — review headline and body text
- `authorName` — display name of the reviewer
- `verifiedBuyer` — true when Yotpo confirms the reviewer purchased the product
- `createdAt` — when the review was posted
- `sentimentScore` — Yotpo's automated sentiment score for the review text (-1 to 1)
- `votesUp`, `votesDown` — "helpful"/"not helpful" vote counts, when other shoppers have voted
- `language` — detected review language
- `isIncentivized` — true when the review was collected as part of an incentivized campaign
- `recordType: "review"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `category` | `category` / `search` / `product` / `reviews` |
| `category` | string | `mattresses` | Category to browse (mode=category) — see the dropdown for all 28 options |
| `searchQuery` | string | – | Keyword search, e.g. `cooling pillow` (mode=search) |
| `productHandles` | array | – | Product handles or full `casper.com/products/...` URLs (mode=product, mode=reviews) |
| `sortBy` | string | `default` | `default` / `price-ascending` / `price-descending` / `title-ascending` / `title-descending` / `newest` / `rating-descending` |
| `priceMin` | integer | – | Minimum price in USD |
| `priceMax` | integer | – | Maximum price in USD |
| `size` | string | – | Only include products offering this exact size (e.g. `Queen`, `King`) |
| `color` | string | – | Only include products offering this exact color (e.g. `Indigo`, `Olive`) |
| `inStockOnly` | boolean | `false` | Exclude products where every variant is out of stock |
| `includeRatings` | boolean | `true` | Enrich each product with its Yotpo rating summary (average, count, star breakdown) |
| `reviewStarRating` | string | `any` | Only fetch reviews with this exact star rating (mode=reviews) |
| `maxItems` | integer | `30` | Hard cap on emitted records — products, or individual reviews when mode=reviews (1–300) |

#### Example: browse the Mattresses category, cheapest first

```json
{
  "mode": "category",
  "category": "mattresses",
  "sortBy": "price-ascending",
  "maxItems": 20
}
````

#### Example: search for cooling pillows under $150

```json
{
  "mode": "search",
  "searchQuery": "cooling pillow",
  "priceMax": 150,
  "maxItems": 25
}
```

#### Example: look up specific products by handle or URL

```json
{
  "mode": "product",
  "productHandles": [
    "casper-one-foam",
    "https://casper.com/products/casper-dream-hybrid",
    "original-pillow"
  ]
}
```

#### Example: get 5-star reviews for a product

```json
{
  "mode": "reviews",
  "productHandles": ["casper-one-foam"],
  "reviewStarRating": "5",
  "maxItems": 50
}
```

### Use cases

- **Price monitoring** — track Casper mattress and bedding prices over time, including sale detection
- **Competitive intelligence** — compare Casper's catalog, pricing tiers and review scores against other DTC mattress brands
- **Affiliate & content sites** — pull product data, images and ratings for mattress review/comparison content
- **Market research** — analyze Casper's product line breadth (mattress families, bedding materials, accessories)
- **Deal aggregators** — surface Casper's clearance and best-seller collections
- **Voice of customer / review analysis** — pull individual review text, ratings and sentiment for a product line
- **Inventory & merchandising checks** — spot out-of-stock sizes/colors across the catalog with `inStockOnly`

### FAQ

**What's the data source?**
Casper's public Shopify storefront JSON API (`casper.com/collections/*.json`, `casper.com/products/*.json`, `casper.com/search/suggest.json`) plus Casper's public Yotpo review-widget API for ratings. No login or API key required.

**Is this affiliated with Casper?**
No — this is an independent third-party actor that reads Casper's public storefront data. It is not affiliated with or endorsed by Casper Sleep Inc.

**Why do some products not have `averageRating`/`totalReviews`?**
Those fields are only included when Casper's review platform (Yotpo) has published review data for that specific product. Newer or low-traffic products (e.g. replacement parts) sometimes have no reviews yet — the field is omitted rather than shown as zero.

**Why do some products not show sale pricing (`compareAtPrice`/`onSale`)?**
Sale pricing reflects whatever Casper has configured for a given variant at the time of the scrape. It's genuinely intermittent — Casper runs promotions seasonally (holidays, Casper's own sale events) rather than year-round, so at any given moment many or most variants may show regular pricing only. When Casper does mark a variant down, `compareAtPrice`, `onSale`, and `discountPercent` appear automatically.

**How does `search` work if there's no full-text search API?**
Casper exposes a predictive search endpoint that returns Casper's own top ~10 relevance-ranked matches. For broader searches (more than 10 results requested), the actor supplements this with a keyword match across product titles, types and tags from the full catalog listing, so you still get complete coverage for common queries.

**Does `sortBy` call Casper's own sort feature?**
Casper's collection/search JSON endpoints don't honor a server-side sort parameter, so sorting is applied to the fetched results directly. `default` preserves Casper's own category/relevance ordering; the other options re-order by price, title, rating, or creation date.

**How do the `size`/`color` filters work when a product has both options?**
Each filter is matched independently against the product's full option set — a product passes `size=Queen` if Queen is offered in any color, and passes `color=Indigo` if Indigo is offered in any size. Using both together narrows to products offering both values (not necessarily as the same purchasable combination). Products that don't have a size or color option at all are always included, since the filter simply doesn't apply to them.

**Why is `inStock` sometimes missing, especially with `mode=product`?**
Casper's category/search listings include stock status for every variant, so `inStock` and the `inStockOnly` filter work fully there. Casper's single-product lookup endpoint (used by `mode=product`) doesn't include stock status at all, so `inStock` is simply omitted on direct handle/URL lookups — `size`, `color`, pricing and every other field are unaffected.

**Why do some products not have `size`/`color` on their variants?**
Casper only uses two variant option axes site-wide: Size and Color. Single-option products (most mattresses, replacement parts) only populate `size`; multi-color products (sheets, duvet covers, pillowcases) populate both. A product with neither (e.g. a single-SKU accessory) omits both fields.

**What does `mode=reviews` return, and is it complete?**
It returns individual customer reviews from Casper's public Yotpo review widget — the same reviews shown on the product page — sorted newest-first. `reviewStarRating` filters to an exact star rating (not "at least"). Reviews are fetched live per run, so very recently deleted/moderated reviews may briefly still appear if Yotpo's cache hasn't updated yet.

**Why do some reviews not have `authorName`, `votesUp`/`votesDown`, or `language`?**
Those fields are only included when Casper/Yotpo actually recorded them for that specific review — an anonymous reviewer, a review nobody has voted on yet, or an unclassified language are all real, common cases, so the field is omitted rather than shown as empty/zero.

**What's in the "All Products" category?**
It mirrors Casper's own storefront "All Products" collection exactly, which is heavily weighted toward bundle SKUs (a mattress + accessories bundle sold as one product per size/color combination) — so most records you'll see there are bundle variants rather than standalone mattresses. It also includes a small number (typically 1-2%) of administrative line items Casper itself lists as products, such as a recycling fee or remote-area shipping surcharge. If you want only standalone products, use a specific category (`mattresses`, `pillows`, `bedding`, etc.) instead of `all`.

**Are prices in USD?**
Yes, Casper.com serves the US market in USD.

**How fresh is the data?**
Every run fetches live data directly from casper.com at request time — there is no caching.

# Actor input Schema

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

What to fetch.

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

Casper product category / collection to browse.

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

Free-text keyword search, e.g. `cooling pillow`, `king mattress`, `duvet`.

## `productHandles` (type: `array`):

Casper product handles (e.g. `casper-one-foam`) or full product URLs (e.g. `https://casper.com/products/casper-one-foam`). Used to fetch exact products (mode=product) or their customer reviews (mode=reviews).

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

Re-order results after fetching. `Default` preserves Casper's own category/search ranking (recommended — this is the retailer's own curated/relevance order).

## `priceMin` (type: `integer`):

Only include products with at least one variant priced at or above this amount.

## `priceMax` (type: `integer`):

Only include products with at least one variant priced at or below this amount.

## `size` (type: `string`):

Only include products that offer this exact size option. Products without a size option are always included.

## `color` (type: `string`):

Only include products that offer this exact color option. Products without a color option are always included.

## `inStockOnly` (type: `boolean`):

Exclude products where every size/color variant is currently out of stock. Products with no stock data are always included.

## `includeRatings` (type: `boolean`):

Enrich each product with its average star rating, review count and star-rating breakdown from Casper's review widget (Yotpo). Disable for a faster run.

## `reviewStarRating` (type: `string`):

Only fetch reviews with this exact star rating. `Any` returns reviews of every rating, newest first.

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

Hard cap on emitted records (products, or individual reviews when mode=reviews).

## Actor input object example

```json
{
  "mode": "category",
  "category": "mattresses",
  "searchQuery": "pillow",
  "productHandles": [
    "casper-one-foam"
  ],
  "sortBy": "default",
  "inStockOnly": false,
  "includeRatings": true,
  "reviewStarRating": "any",
  "maxItems": 10
}
```

# Actor output Schema

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

Dataset containing all scraped Casper products (category/search/product modes) or individual customer reviews (reviews mode).

# 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": "category",
    "category": "mattresses",
    "searchQuery": "pillow",
    "productHandles": [
        "casper-one-foam"
    ],
    "sortBy": "default",
    "inStockOnly": false,
    "includeRatings": true,
    "reviewStarRating": "any",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/casper-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": "category",
    "category": "mattresses",
    "searchQuery": "pillow",
    "productHandles": ["casper-one-foam"],
    "sortBy": "default",
    "inStockOnly": False,
    "includeRatings": True,
    "reviewStarRating": "any",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/casper-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": "category",
  "category": "mattresses",
  "searchQuery": "pillow",
  "productHandles": [
    "casper-one-foam"
  ],
  "sortBy": "default",
  "inStockOnly": false,
  "includeRatings": true,
  "reviewStarRating": "any",
  "maxItems": 10
}' |
apify call crawlerbros/casper-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Casper Scraper",
        "description": "Scrape Casper.com mattresses, pillows, bedding, bed frames & furniture. Browse by category, search by keyword, or look up exact products by handle/URL. Full pricing (incl. sale pricing), variants, images, descriptions, and Yotpo review ratings. No auth, no proxy.",
        "version": "1.0",
        "x-build-id": "br6xAGyUVGKfUQZ07"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~casper-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-casper-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~casper-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-casper-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~casper-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-casper-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": [
                            "category",
                            "search",
                            "product",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "category"
                    },
                    "category": {
                        "title": "Category (mode=category)",
                        "enum": [
                            "mattresses",
                            "the-one",
                            "the-hybrids",
                            "the-maxes",
                            "the-foams",
                            "cooling-mattresses",
                            "pillows",
                            "classic-pillows",
                            "cooling-pillows",
                            "specialty-pillows",
                            "bedding",
                            "sheets",
                            "duvets",
                            "quilts-blankets-throws",
                            "bed-frames",
                            "adjustable-bases",
                            "headboards",
                            "furniture",
                            "protectors",
                            "mattress-toppers",
                            "cooling-collection",
                            "cozy-collection",
                            "accessories",
                            "replacement-parts",
                            "mattresses-and-furniture-collection",
                            "clearance",
                            "best-sellers",
                            "all"
                        ],
                        "type": "string",
                        "description": "Casper product category / collection to browse.",
                        "default": "mattresses"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text keyword search, e.g. `cooling pillow`, `king mattress`, `duvet`."
                    },
                    "productHandles": {
                        "title": "Product handles or URLs (mode=product / mode=reviews)",
                        "type": "array",
                        "description": "Casper product handles (e.g. `casper-one-foam`) or full product URLs (e.g. `https://casper.com/products/casper-one-foam`). Used to fetch exact products (mode=product) or their customer reviews (mode=reviews).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "default",
                            "price-ascending",
                            "price-descending",
                            "title-ascending",
                            "title-descending",
                            "newest",
                            "rating-descending"
                        ],
                        "type": "string",
                        "description": "Re-order results after fetching. `Default` preserves Casper's own category/search ranking (recommended — this is the retailer's own curated/relevance order).",
                        "default": "default"
                    },
                    "priceMin": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Only include products with at least one variant priced at or above this amount."
                    },
                    "priceMax": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Only include products with at least one variant priced at or below this amount."
                    },
                    "size": {
                        "title": "Size (variant filter)",
                        "enum": [
                            "Twin",
                            "Twin XL",
                            "Full",
                            "Queen",
                            "King",
                            "California King",
                            "Split King",
                            "Twin/Twin XL",
                            "Full/Queen",
                            "King/Cal King",
                            "Twin-Twin XL",
                            "Twin/TwinXL",
                            "Standard",
                            "Double",
                            "Single",
                            "Small",
                            "Medium",
                            "Large",
                            "One Size",
                            "One-Size",
                            "One Pin",
                            "10 Pounds",
                            "15 Pounds",
                            "20 Pounds",
                            "Small Items",
                            "Large Items",
                            "Glow Single",
                            "Glow Double"
                        ],
                        "type": "string",
                        "description": "Only include products that offer this exact size option. Products without a size option are always included."
                    },
                    "color": {
                        "title": "Color (variant filter)",
                        "enum": [
                            "Ash",
                            "Autumn Multi",
                            "Big Stripe Gray",
                            "Blue",
                            "Charcoal",
                            "Chocolate",
                            "Cream",
                            "Dark Oak",
                            "Driftwood",
                            "Dune",
                            "Dusty Rose",
                            "Fireside",
                            "Fog",
                            "Fog Blue",
                            "Gray",
                            "Indigo",
                            "Light Gray",
                            "Marshmellow",
                            "Midnight",
                            "Midnight Gray",
                            "Natural",
                            "Natural Oak",
                            "Navy",
                            "Navy Tweed",
                            "Oat",
                            "Oatmilk",
                            "Olive",
                            "Peach",
                            "Petal",
                            "Pink",
                            "Sand",
                            "Slate",
                            "Small Stripe Gray",
                            "Spice",
                            "Taupe",
                            "White"
                        ],
                        "type": "string",
                        "description": "Only include products that offer this exact color option. Products without a color option are always included."
                    },
                    "inStockOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "Exclude products where every size/color variant is currently out of stock. Products with no stock data are always included.",
                        "default": false
                    },
                    "includeRatings": {
                        "title": "Include review ratings",
                        "type": "boolean",
                        "description": "Enrich each product with its average star rating, review count and star-rating breakdown from Casper's review widget (Yotpo). Disable for a faster run.",
                        "default": true
                    },
                    "reviewStarRating": {
                        "title": "Review star rating (mode=reviews)",
                        "enum": [
                            "any",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Only fetch reviews with this exact star rating. `Any` returns reviews of every rating, newest first.",
                        "default": "any"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Hard cap on emitted records (products, or individual reviews when mode=reviews).",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
