# Ulta Beauty Scraper (`solidcode/ulta-scraper`) Actor

\[💰 $1.20/1K products + $0.20/1K reviews] Extract Ulta Beauty products and customer reviews — brands, prices, sale prices, SKUs, ingredients, images, ratings, and full review text. Search by keyword or paste product and category URLs.

- **URL**: https://apify.com/solidcode/ulta-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (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 $1.20 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Ulta Beauty Scraper

Pull beauty products and customer reviews from Ulta Beauty at scale — brands, regular and sale pricing, full ingredient lists, star-rating breakdowns, and every review with its verified-buyer flag and helpful-vote counts. Search by keyword, or paste product and category URLs and the scraper detects the page type for you. Built for beauty brand analysts, e-commerce sellers, and market researchers who need structured Ulta catalog and review data without copying it product by product.

### Why This Scraper?

- **Two linked record types in one run** — a `product` row for every item plus a `review` row for every customer review, each review tagged with its parent product name and SKU so it stands alone in a spreadsheet.
- **Full ingredient lists, usage, and warnings** — the complete INCI ingredient string, "how to use" directions, and Prop 65 / restriction warnings pulled from each product page, not just the marketing blurb.
- **Complete review text with buyer signals** — title, full body, reviewer name and type, location, date, verified-purchase flag, plus separate helpful and not-helpful vote counts and the reviewer's "bottom line" summary.
- **1–5 star rating distribution and recommend %** — every product carries the exact count of reviews at each star level plus the percentage of reviewers who recommend it — sentiment math done for you.
- **Sale price, list price, and discount tracking** — regular price, current sale price, and the discount percentage side by side, so you can spot markdowns the moment they hit.
- **Six sort orders** — Relevance, Best Sellers, Top Rated, Newest Arrivals, Price Low→High, and Price High→Low, applied server-side across searches and category pages.
- **Keyword search OR URL input, auto-detected** — type "vitamin c serum" or paste a product, category, or brand page URL; mix all three in one run and the scraper routes each automatically.
- **Per-product review cap** — set how many reviews to pull per product (or pull them all) so a bestseller with 16,000+ reviews never blows up a run.
- **Stable IDs on every row** — SKU and Ulta product ID on both products and reviews, ready to join against your own catalog or de-duplicate across runs.

### Use Cases

**Brand & Competitor Monitoring**
- Track a competitor's full Ulta catalog, pricing, and stock status
- Watch for new product launches with the Newest Arrivals sort
- Monitor sale and discount activity across a brand or category
- Benchmark your products' ratings against rival brands

**Product Research & Development**
- Mine ingredient lists across a category to spot formulation trends
- Compare "how to use" directions and claims across competing products
- Identify which formats and finishes earn the highest ratings
- Build a structured ingredient database for regulatory or marketing review

**Review Mining & Sentiment**
- Pull thousands of reviews to surface recurring praise and complaints
- Use the 1–5 star distribution and recommend % to quantify satisfaction
- Filter to verified-purchase reviews for higher-trust feedback
- Rank reviews by helpful votes to find the most influential opinions

**Pricing Intelligence**
- Track regular vs. sale prices and discount depth over time
- Compare price positioning across brands in the same category
- Spot price-low-to-high entry points for value shoppers
- Feed live pricing into repricing and margin models

**Catalog & Lead Building**
- Export a clean, structured product feed for a whole category or brand
- Build affiliate or comparison catalogs with images, prices, and ratings
- Enrich an existing SKU list with ratings, reviews, and ingredients
- Power dashboards and alerts on stock, price, and review changes

### Getting Started

#### Search by Keyword

The simplest way to start — one keyword:

```json
{
    "searchTerms": ["vitamin c serum"],
    "maxResults": 25
}
````

#### Scrape Specific Products and Categories

Paste product pages, category pages, or brand pages — mix freely:

```json
{
    "startUrls": [
        "https://www.ulta.com/shop/skin-care/moisturizers",
        "https://www.ulta.com/p/hydro-boost-water-gel-pimprod2007499"
    ],
    "maxResults": 100,
    "includeReviews": false
}
```

#### Advanced — Top-Rated Sweep with Review Cap

Pull the top-rated foundations and the 50 most recent reviews for each:

```json
{
    "searchTerms": ["foundation"],
    "sortBy": "top_rated",
    "maxResults": 200,
    "includeReviews": true,
    "maxReviewsPerProduct": 50
}
```

### Input Reference

#### What to Scrape

Use either or both. Leave one empty to rely on the other.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["moisturizer"]` | Keywords to search on Ulta. Each term collects its own feed of matching products — the fastest way to scan a category. |
| `startUrls` | string\[] | — | Ulta URLs — individual product pages or category/brand listing pages. The page type is detected automatically. |

#### Search Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Relevance` | Order products are collected from searches and category pages: Relevance, Best Sellers, Top Rated, Newest Arrivals, Price Low→High, Price High→Low. Individual product URLs are unaffected. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of products to collect across all searches and URLs. Set to 0 for no limit. Reviews do not count against this. |
| `includeReviews` | boolean | `true` | Collect each product's customer reviews. Turn off for faster, cheaper runs when you only need product and pricing data. |
| `maxReviewsPerProduct` | integer | `20` | Maximum reviews to collect per product. Set to 0 to collect all available reviews, up to 1,000 per product. Only applies when reviews are on. |

### Output

The dataset contains two record types, told apart by the `recordType` field. A product row is pushed first, followed by its review rows.

#### Product Record

```json
{
    "recordType": "product",
    "productId": "pimprod2007499",
    "sku": "2563021",
    "name": "Hydro Boost Water Gel with Hyaluronic Acid",
    "brand": "Neutrogena",
    "url": "https://www.ulta.com/p/hydro-boost-water-gel-pimprod2007499",
    "price": 25.99,
    "salePrice": 19.99,
    "discountPercent": 23,
    "currency": "USD",
    "inStock": true,
    "availability": "https://schema.org/InStock",
    "description": "An oil-free, lightweight gel moisturizer that instantly quenches dry skin...",
    "ingredients": "Water, Dimethicone, Glycerin, Dimethicone/Vinyl Dimethicone Crosspolymer, Sodium Hyaluronate...",
    "howToUse": "Apply liberally to face and neck daily, or as needed.",
    "warnings": "For external use only. Avoid contact with eyes.",
    "images": ["https://media.ulta.com/i/ulta/2563021"],
    "rating": 4.6,
    "reviewCount": 8412,
    "recommendPercent": 91.0,
    "ratingDistribution": { "1": 120, "2": 95, "3": 310, "4": 1840, "5": 6047 },
    "reviewsCollected": 50,
    "scrapedAt": "2026-06-17T14:30:00Z"
}
```

##### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"product"` for product rows |
| `productId` | string | Ulta product identifier |
| `sku` | string | Ulta SKU identifier |
| `name` | string | Product name |
| `brand` | string | Brand name |
| `url` | string | Canonical product page URL |
| `inStock` | boolean | Whether the product is in stock |
| `availability` | string | Raw availability status |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

##### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Regular / list price |
| `salePrice` | number | Sale price when discounted |
| `discountPercent` | number | Discount percentage off the regular price |
| `currency` | string | Currency code (USD) |

##### Ratings & Reviews Summary

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Overall average star rating |
| `reviewCount` | number | Total reviews displayed on Ulta |
| `recommendPercent` | number | Percentage of reviewers who recommend the product |
| `ratingDistribution` | object | Count of reviews at each star level (1–5) |
| `reviewsCollected` | number | How many reviews this run pulled for the product |

##### Content & Media

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full product description |
| `ingredients` | string | Complete ingredient list |
| `howToUse` | string | Usage directions |
| `warnings` | string | Restrictions and safety warnings |
| `images` | string\[] | Product image URLs |

#### Review Record

```json
{
    "recordType": "review",
    "productId": "pimprod2007499",
    "sku": "2563021",
    "productName": "Hydro Boost Water Gel with Hyaluronic Acid",
    "reviewId": "a1b2c3d4",
    "rating": 5,
    "title": "Holy grail moisturizer",
    "body": "I have combination skin and this is the only gel that hydrates without making me oily...",
    "authorName": "SkincareFan22",
    "authorType": "verified",
    "datePublished": "2026-05-02T00:00:00Z",
    "location": "California",
    "verifiedPurchase": true,
    "recommends": true,
    "helpfulVotes": 47,
    "notHelpfulVotes": 2,
    "bottomLine": "Yes",
    "media": ["https://media.ulta.com/review/example.jpg"]
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` for review rows |
| `productId` | string | Parent product identifier (for joining) |
| `sku` | string | Parent product SKU |
| `productName` | string | Parent product name |
| `reviewId` | string | Unique review identifier |
| `rating` | number | Star rating, 1–5 |
| `title` | string | Review headline |
| `body` | string | Full review text |
| `authorName` | string | Reviewer display name |
| `authorType` | string | `user`, `verified`, or `staff` |
| `datePublished` | string | ISO 8601 submission date |
| `location` | string | Reviewer location |
| `verifiedPurchase` | boolean | Whether the reviewer is a verified buyer |
| `recommends` | boolean | Whether the reviewer recommends the product (`null` if not stated) |
| `helpfulVotes` | number | Count of helpful votes |
| `notHelpfulVotes` | number | Count of not-helpful votes |
| `bottomLine` | string | Reviewer's raw recommend answer (`"Yes"` / `"No"`) |
| `media` | string\[] | Attached photo/video URLs |

### Tips for Best Results

- **Start small to test** — set `maxResults` to 10–25 on your first run to confirm the data fits your needs, then scale up.
- **Turn off reviews for catalog sweeps** — when you only need products, prices, and ingredients, set `includeReviews` to false for much faster, cheaper runs.
- **Cap reviews on bestsellers** — popular Ulta products carry thousands of reviews (some exceed 16,000). Keep `maxReviewsPerProduct` at 20–50 to control cost. Setting it to 0 collects all reviews up to 1,000 per product — use that only when you genuinely need deep review history.
- **Use category URLs to sweep a whole brand** — paste a brand or category page URL to capture its entire product grid in one pass instead of typing dozens of keywords.
- **Match the sort to your goal** — use Best Sellers for demand signals, Top Rated for the highest-satisfaction items, and Newest Arrivals to catch launches early.
- **The rating distribution beats the average** — a 4.6-star product with a long tail of 1-star reviews tells a different story than the average alone; use `ratingDistribution` and `recommendPercent` for true sentiment.
- **Join reviews back to products on `sku`** — both record types share `sku` and `productId`, so you can split the dataset by `recordType` and rejoin cleanly in any spreadsheet or database.

### Pricing

**Charged per product plus per review collected** — you pay for the results you actually get, not for compute time. Products and reviews are billed as two separate events, so review-light runs cost a fraction of full review pulls.

- **$1.20 per 1,000 products**
- **$0.20 per 1,000 reviews**

The table below shows how the two events combine across typical run shapes:

| Run shape | Products | Reviews | Product cost | Review cost | Total |
|-----------|----------|---------|--------------|-------------|-------|
| Catalog only (reviews off) | 100 | 0 | $0.12 | — | $0.12 |
| Products + light reviews | 100 | 2,000 | $0.12 | $0.40 | $0.52 |
| Full pull | 1,000 | 50,000 | $1.20 | $10.00 | $11.20 |

A "product" is one unique product row; a "review" is one customer-review row. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.** Bronze, Silver, and Gold loyalty-tier subscribers pay progressively less; discounts apply automatically in the Apify Console.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, product analysis, and competitive intelligence. Users are responsible for complying with applicable laws and Ulta Beauty's Terms of Service. Collect only publicly available information, respect personal data in customer reviews, and do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on Ulta, for example 'moisturizer' or 'vitamin c serum'. Each term collects its own feed of matching products. The fastest way to scan a whole product category.

## `startUrls` (type: `array`):

Paste one or more Ulta URLs — individual product pages or category/brand listing pages. The scraper detects the page type automatically. Leave empty to use the search terms above instead.

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

Order in which products are collected from searches and category pages. Only applies to search terms and category URLs — individual product URLs are unaffected.

## `maxResults` (type: `integer`):

Maximum number of products to collect across all searches and URLs. Set to 0 for no limit. Tip: start with 10-50 to test, then increase. Reviews collected for each product do not count against this limit.

## `includeReviews` (type: `boolean`):

Collect each product's customer reviews — rating, title, text, author, date, verified-purchase status, and helpful votes. Turn this off for faster, cheaper runs when you only need product and pricing data.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews to collect for each product. Set to 0 to collect all available reviews, up to 1,000 per product (popular Ulta products can have over 16,000 reviews, so this cap keeps runs fast and affordable). Only applies when 'Include Customer Reviews' is on.

## Actor input object example

```json
{
  "searchTerms": [
    "moisturizer"
  ],
  "startUrls": [
    "https://www.ulta.com/shop/skin-care/moisturizers"
  ],
  "sortBy": "relevance",
  "maxResults": 100,
  "includeReviews": true,
  "maxReviewsPerProduct": 20
}
```

# Actor output Schema

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

Table of scraped products with key fields.

## `reviews` (type: `string`):

Table of customer reviews collected for the 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 = {
    "searchTerms": [
        "moisturizer"
    ],
    "startUrls": [
        "https://www.ulta.com/shop/skin-care/moisturizers"
    ],
    "sortBy": "relevance",
    "maxResults": 100,
    "includeReviews": false,
    "maxReviewsPerProduct": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/ulta-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 = {
    "searchTerms": ["moisturizer"],
    "startUrls": ["https://www.ulta.com/shop/skin-care/moisturizers"],
    "sortBy": "relevance",
    "maxResults": 100,
    "includeReviews": False,
    "maxReviewsPerProduct": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/ulta-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 '{
  "searchTerms": [
    "moisturizer"
  ],
  "startUrls": [
    "https://www.ulta.com/shop/skin-care/moisturizers"
  ],
  "sortBy": "relevance",
  "maxResults": 100,
  "includeReviews": false,
  "maxReviewsPerProduct": 20
}' |
apify call solidcode/ulta-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ulta Beauty Scraper",
        "description": "[💰 $1.20/1K products + $0.20/1K reviews] Extract Ulta Beauty products and customer reviews — brands, prices, sale prices, SKUs, ingredients, images, ratings, and full review text. Search by keyword or paste product and category URLs.",
        "version": "1.0",
        "x-build-id": "DhrrFghjfOZKHYHdH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~ulta-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-ulta-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/solidcode~ulta-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-ulta-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/solidcode~ulta-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-ulta-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search on Ulta, for example 'moisturizer' or 'vitamin c serum'. Each term collects its own feed of matching products. The fastest way to scan a whole product category.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Ulta URLs",
                        "type": "array",
                        "description": "Paste one or more Ulta URLs — individual product pages or category/brand listing pages. The scraper detects the page type automatically. Leave empty to use the search terms above instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "best_sellers",
                            "top_rated",
                            "newest",
                            "price_low_high",
                            "price_high_low"
                        ],
                        "type": "string",
                        "description": "Order in which products are collected from searches and category pages. Only applies to search terms and category URLs — individual product URLs are unaffected.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max Products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to collect across all searches and URLs. Set to 0 for no limit. Tip: start with 10-50 to test, then increase. Reviews collected for each product do not count against this limit.",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Include Customer Reviews",
                        "type": "boolean",
                        "description": "Collect each product's customer reviews — rating, title, text, author, date, verified-purchase status, and helpful votes. Turn this off for faster, cheaper runs when you only need product and pricing data.",
                        "default": true
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews Per Product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect for each product. Set to 0 to collect all available reviews, up to 1,000 per product (popular Ulta products can have over 16,000 reviews, so this cap keeps runs fast and affordable). Only applies when 'Include Customer Reviews' is on.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```