# Ulta Reviews Scraper (Ulta.com) (`mof1re/ulta-reviews-scraper`) Actor

⚡ Scrapes Ulta.com product reviews via raw HTTP requests. Structured output: rating, review title & text, reviewer info, helpful/not-helpful votes, verified buyer badges, media, and per-product rating averages. Filter by star rating, sort order, verified-purchase only, and keyword.

- **URL**: https://apify.com/mof1re/ulta-reviews-scraper.md
- **Developed by:** [Vladimir Efimenco](https://apify.com/mof1re) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 results

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.com Reviews Scraper | ⚡ Fast Browserless

Browserless Ulta.com review scraper built on the site's internal review API, not a headless browser. Returns full review content alongside reviewer details, verification badges, media, and product-wide rating stats — for any Ulta product page.

### ⚡ Why this one

- **Full dataset, not a summary** — every review comes with the review text, rating, reviewer info, and helpful/not-helpful vote counts.
- **Product-wide rating stats included** — average rating and recommended ratio are attached alongside each review.
- **GTIN resolution built in** — reviews are matched to a GTIN via an internal historical SKU-to-GTIN mapping, since Ulta no longer exposes GTIN on the product page itself.
- **Flexible filtering** — star rating, sort order (Newest, Most Helpful, Highest/Lowest Rating, Oldest, With Images), verified-purchase only, and keyword search that can run server-side or locally.
- **Batch by design** — scrape multiple products in a single run (up to 5 in parallel), with a configurable result cap per product or unlimited collection.
- **Proxies included** — proxy pool is built in. You don't need to bring your own.
- **Fast** — no browser, no rendering wait. Pure HTTP calls to the same internal API the Ulta site uses.

### 📋 Example output

```json
[
  {
    "product_id": "pimprod2051122",
    "product_gtin": null,
    "review_id": 583417318,
    "review_title": "It blurs effortlessly and the tones are beautiful",
    "review_text": "This trio of Morphe blushes has very good pigmentation, blends easily and allows you to create from a soft look to a more intense one. I like that it includes matte and luminous finishes, so you can use each tone separately or combine them to give more dimension. The formula feels light and the color lasts well during the day",
    "review_locale": "en_US",
    "review_rating": 5,
    "review_likes": 0,
    "review_dislikes": 0,
    "review_helpful_score": 1684,
    "reviewed_source": null,
    "review_created_at": "2026-07-07",
    "review_updated_at": "2026-07-07",
    "review_media": [
      {
        "id": "583417301",
        "uri": "//res.cloudinary.com/powerreviews/image/upload/f_auto,q_auto,h_768,w_auto/d_portal-no-product-image_ttlfpi.svg/prod/przvqicg5ia7oqkfscdh.jpg",
        "helpful_votes": 0,
        "not_helpful_votes": 0,
        "type": "image",
        "caption": "M202"
      },
      {
        "id": "583417223",
        "uri": "//res.cloudinary.com/powerreviews/image/upload/f_auto,q_auto,h_768,w_auto/d_portal-no-product-image_ttlfpi.svg/prod/sdcbdo5xhllq39m5fvta.jpg",
        "helpful_votes": 0,
        "not_helpful_votes": 0,
        "type": "image",
        "caption": "Blind Date"
      }
    ],
    "reviewer_nickname": "Melissa",
    "reviewer_location": "Hutto, Texas",
    "reviewer_is_staff": false,
    "reviewer_is_verified_buyer": false,
    "reviewer_is_verified": false,
    "reviews_metrics": {
      "total_reviews": 166,
      "recommended_ratio": 0.98,
      "rating_average": 4.85
    },
    "search_keyword": "good",
    "keyword_match": true
  },
  {
    "product_id": "pimprod2051122",
    "product_gtin": null,
    "review_id": 582813831,
    "review_title": "I like",
    "review_text": "I love every Morphe product, and this one was no exception. The pigmentation is 10/10, on par with any high-end brand. It blends like butter, and the staying power is good. I absolutely love it.",
    "review_locale": "en_US",
    "review_rating": 5,
    "review_likes": 0,
    "review_dislikes": 0,
    "review_helpful_score": 1532,
    "reviewed_source": null,
    "review_created_at": "2026-06-23",
    "review_updated_at": "2026-06-24",
    "review_media": [
      {
        "id": "582813836",
        "uri": "//res.cloudinary.com/powerreviews/image/upload/f_auto,q_auto,h_768,w_auto/d_portal-no-product-image_ttlfpi.svg/prod/edjisu6zsdynlvf1k04f.jpg",
        "helpful_votes": 0,
        "not_helpful_votes": 0,
        "type": "image",
        "caption": "I love"
      }
    ],
    "reviewer_nickname": "Direy",
    "reviewer_location": "NY",
    "reviewer_is_staff": false,
    "reviewer_is_verified_buyer": false,
    "reviewer_is_verified": false,
    "reviews_metrics": {
      "total_reviews": 166,
      "recommended_ratio": 0.98,
      "rating_average": 4.85
    },
    "search_keyword": "good",
    "keyword_match": true
  },
  {
    "product_id": "pimprod2051122",
    "product_gtin": null,
    "review_id": 582145062,
    "review_title": "Loveeeee",
    "review_text": "I love this blush I love the excellent pigmentation and the best good price😍",
    "review_locale": "en_US",
    "review_rating": 5,
    "review_likes": 2,
    "review_dislikes": 0,
    "review_helpful_score": 1264,
    "reviewed_source": null,
    "review_created_at": "2026-06-11",
    "review_updated_at": "2026-06-19",
    "review_media": [
      {
        "id": "582145063",
        "uri": "//res.cloudinary.com/powerreviews/video/upload/v1781134681/prod/ls7jxjddq6ckftmvkzkc.mp4",
        "helpful_votes": 0,
        "not_helpful_votes": 0,
        "type": "video",
        "caption": "Love blush love color"
      }
    ],
    "reviewer_nickname": "Elizabeth",
    "reviewer_location": "Maryland Stevensville",
    "reviewer_is_staff": false,
    "reviewer_is_verified_buyer": false,
    "reviewer_is_verified": false,
    "reviews_metrics": {
      "total_reviews": 166,
      "recommended_ratio": 0.98,
      "rating_average": 4.85
    },
    "search_keyword": "good",
    "keyword_match": true
  }
]
````

### 🧾 What you get, per review

- Review content — title, text, rating, locale, created/updated date
- Reviewer info — nickname, location, staff/verified-buyer/verified-reviewer badges
- Helpfulness — helpful votes, not-helpful votes, helpful score
- Media — photos/videos attached to the review, if any
- Product-wide stats — total review count, recommended ratio, average rating
- GTIN — resolved from SKU via internal mapping, where available
- Keyword match — whether the search query matched this review

### 🔍 How keyword search works

The `search` field is a single query, same as what you'd type into Ulta's own review search box.

- **`searchIsLocalFilter` unchecked (default):** the query is sent to Ulta as a server-side filter — only matching reviews are returned, and every one of them is marked `keyword_match: true`.
- **`searchIsLocalFilter` checked:** the query is *not* sent to Ulta. Every review is still fetched and returned, but each one is checked locally against the title and text, and gets a `keyword_match` flag showing whether it was found.

Use the checked option when you want the full, unfiltered review set but still want to know which reviews mention your keyword.

### 🧬 How GTIN resolution works

Ulta product pages no longer expose a GTIN directly. This actor resolves GTIN from the product's SKU (parsed from the input URL, e.g. `?sku=2638343`) against an internal historical SKU-to-GTIN mapping.

- If the SKU is present in the URL and found in the mapping — `product_gtin` is populated.
- If the SKU is missing from the URL, or not found in the mapping — `product_gtin` is `null`.

### 🔧 Input options

| Field | Description |
|---|---|
| `listingUrls` | One or more Ulta product page URLs |
| `maxResults` | Max reviews to collect per product. Leave empty to collect all available |
| `sort` | Sort order — Newest, Most Helpful, Highest Rating, Lowest Rating, Oldest, With Images |
| `rating` | Filter by a single star rating (1–5) |
| `nativeOnly` | If checked, only show reviews from verified Ulta purchasers |
| `search` | Keyword to search for in reviews |
| `searchIsLocalFilter` | If checked, `search` tags reviews locally instead of filtering them via Ulta |

### 📊 Data Fields

#### 📝 Review Details

| Field | Description |
|---|---|
| `product_id` | Ulta product ID this review belongs to |
| `product_gtin` | GTIN resolved from SKU via internal mapping, if available |
| `review_id` | Unique ID of the review |
| `review_rating` | Reviewer's star rating |
| `review_title` / `review_text` | Review headline and body text |
| `review_locale` | Locale of the review |
| `review_created_at` / `review_updated_at` | Dates the review was created/updated |
| `review_media` | Photos/videos attached to the review |
| `reviewed_source` | Brand name associated with the review |

#### 👤 Reviewer

| Field | Description |
|---|---|
| `reviewer_nickname` | Reviewer's display name |
| `reviewer_location` | Reviewer's stated location |
| `reviewer_is_staff` | True if flagged as a staff reviewer |
| `reviewer_is_verified_buyer` | True if a verified purchaser |
| `reviewer_is_verified` | True if a verified reviewer |

#### ⭐ Helpfulness & Matching

| Field | Description |
|---|---|
| `review_likes` / `review_dislikes` | Helpful / not-helpful vote counts |
| `review_helpful_score` | Computed helpfulness score |
| `reviews_metrics` | Product-wide aggregate stats — total reviews, recommended ratio, average rating |
| `search_keyword` | The search keyword provided in actor input, if any |
| `keyword_match` | True if the query matched this review — verified locally, or because Ulta's own filter already applied it |

### 🚀 Running the actor

#### Via Apify Console

Open the actor page, fill in the input form, and click **Start**.

#### Via Apify API — Python

```python
import requests

APIFY_TOKEN = "your_apify_token"
ACTOR_ID = "mof1re~ulta-reviews-scraper"

run_input = {
    "listingUrls": [
        {"url": "https://www.ulta.com/p/cheek-thrills-multi-finish-face-trio-pimprod2051122?sku=2638343"}
    ],
    "maxResults": 200,
    "sort": "Newest",
    "rating": "",
    "nativeOnly": False,
    "search": "",
    "searchIsLocalFilter": False
}

response = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR_ID}/run-sync-get-dataset-items",
    params={"token": APIFY_TOKEN},
    json=run_input,
)

reviews = response.json()
print(f"Fetched {len(reviews)} reviews")
```

#### Via Apify API — Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'your_apify_token' });

const input = {
    listingUrls: [
        { url: 'https://www.ulta.com/p/cheek-thrills-multi-finish-face-trio-pimprod2051122?sku=2638343' }
    ],
    maxResults: 200,
    sort: 'Newest',
    rating: '',
    nativeOnly: false,
    search: '',
    searchIsLocalFilter: false,
};

const run = await client.actor('mof1re/ulta-reviews-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Fetched ${items.length} reviews`);
```

#### Example input JSON

```json
{
  "listingUrls": [
    { "url": "https://www.ulta.com/p/cheek-thrills-multi-finish-face-trio-pimprod2051122?sku=2638343" }
  ],
  "maxResults": 200,
  "sort": "MediaSort",
  "rating": "5",
  "nativeOnly": true,
  "search": "good",
  "searchIsLocalFilter": false
}
```

### 💳 Pricing

Pay-per-result. You're charged for reviews actually delivered, not for pages fetched or requests made.

### ⚠️ Notes

- Free-tier accounts are capped at a small sample size per run, and to a single product per run — upgrade to a paid Apify plan for full volume and batch scraping.
- Data reflects what's publicly listed on ulta.com at the time of the run; the source updates continuously.
- GTIN resolution depends on the internal SKU mapping and is not guaranteed for every product.

### 🔗 See also

Need reviews from another platform? Check out:

- [Booking.com Reviews Scraper](https://apify.com/mof1re/booking-reviews-scraper-browserless)
- [AirBnb Reviews Scraper](https://apify.com/mof1re/airbnb-reviews-scraper-browserless)
- [Trustpilot Reviews Scraper](https://apify.com/mof1re/trustpilot-scraper-fast-browserlessapif)
- [TripAdvisor Reviews Scraper](https://apify.com/mof1re/tripadvisor-reviews-scraper-browserless)

# Actor input Schema

## `listingUrls` (type: `array`):

Ulta product URLs to scrape reviews from.

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

Maximum number of reviews to scrape per product. Leave empty to try to get all reviews.

## `sort` (type: `string`):

How to sort reviews.

## `rating` (type: `string`):

Filter reviews by a single star rating. Leave empty to include all ratings.

## `nativeOnly` (type: `boolean`):

If enabled, only show reviews from verified Ulta purchasers.

## `search` (type: `string`):

Filter reviews containing this keyword.

## `searchIsLocalFilter` (type: `boolean`):

If enabled, keyword filtering is applied locally to already-fetched reviews. If disabled, the keyword is sent to Ulta and results returned are treated as already matched.

## Actor input object example

```json
{
  "listingUrls": [
    {
      "url": "https://www.ulta.com/p/cheek-thrills-multi-finish-face-trio-pimprod2051122?sku=2638343"
    }
  ],
  "maxResults": 100,
  "sort": "Newest",
  "nativeOnly": false,
  "searchIsLocalFilter": false
}
```

# Actor output Schema

## `jobAds` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "listingUrls": [
        {
            "url": "https://www.ulta.com/p/cheek-thrills-multi-finish-face-trio-pimprod2051122?sku=2638343"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mof1re/ulta-reviews-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 = { "listingUrls": [{ "url": "https://www.ulta.com/p/cheek-thrills-multi-finish-face-trio-pimprod2051122?sku=2638343" }] }

# Run the Actor and wait for it to finish
run = client.actor("mof1re/ulta-reviews-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 '{
  "listingUrls": [
    {
      "url": "https://www.ulta.com/p/cheek-thrills-multi-finish-face-trio-pimprod2051122?sku=2638343"
    }
  ]
}' |
apify call mof1re/ulta-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ulta Reviews Scraper (Ulta.com)",
        "description": "⚡ Scrapes Ulta.com product reviews via raw HTTP requests. Structured output: rating, review title & text, reviewer info, helpful/not-helpful votes, verified buyer badges, media, and per-product rating averages. Filter by star rating, sort order, verified-purchase only, and keyword.",
        "version": "0.1",
        "x-build-id": "6Tb6iRfaerHpjykNC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mof1re~ulta-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mof1re-ulta-reviews-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/mof1re~ulta-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mof1re-ulta-reviews-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/mof1re~ulta-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mof1re-ulta-reviews-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": [
                    "listingUrls"
                ],
                "properties": {
                    "listingUrls": {
                        "title": "🔗 Product URLs",
                        "type": "array",
                        "description": "Ulta product URLs to scrape reviews from.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "🔢 Max reviews per product",
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per product. Leave empty to try to get all reviews.",
                        "default": 100
                    },
                    "sort": {
                        "title": "↕️ Sort order",
                        "enum": [
                            "Newest",
                            "MostHelpful",
                            "HighestRating",
                            "LowestRating",
                            "Oldest",
                            "MediaSort"
                        ],
                        "type": "string",
                        "description": "How to sort reviews.",
                        "default": "Newest"
                    },
                    "rating": {
                        "title": "⭐ Rating",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Filter reviews by a single star rating. Leave empty to include all ratings."
                    },
                    "nativeOnly": {
                        "title": "✅ Ulta customers only",
                        "type": "boolean",
                        "description": "If enabled, only show reviews from verified Ulta purchasers.",
                        "default": false
                    },
                    "search": {
                        "title": "🔍 Search keyword",
                        "type": "string",
                        "description": "Filter reviews containing this keyword."
                    },
                    "searchIsLocalFilter": {
                        "title": "🔄 Search is local filter",
                        "type": "boolean",
                        "description": "If enabled, keyword filtering is applied locally to already-fetched reviews. If disabled, the keyword is sent to Ulta and results returned are treated as already matched.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
