# PrettyLittleThing Fashion Scraper (`crawlerbros/prettylittlething-fashion-scraper`) Actor

Scrape prettylittlething.com fashion products. Search by keyword or browse any category (dresses, tops, co-ords, shoes, accessories, and more). Filter by size, colour, price, and sale status. Returns pricing, sizes, colours, images, and product URLs.

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

## PrettyLittleThing Fashion Scraper

Scrape **prettylittlething.com** product data at scale. Search by keyword or browse any category — dresses, tops, co-ords, shoes, accessories, and more — and filter by size, colour, price, and sale status. Returns pricing (current + original), available sizes, colour variants, images, and canonical product URLs. No login, no cookies, no residential proxy required.

### What this actor does

- **Two modes:** `search` (free-text keyword) and `byCategory` (browse a curated category tree)
- **Filters:** UK size, colour family, brand, min/max price, on-sale-only
- **Multi-brand marketplace aware:** prettylittlething.com sells more than its own house label — boohoo, KarenMillen, Coast, Wallis, Dorothy Perkins, and 350+ other brands are all fulfilled through the same storefront. Use `brand` / `customBrand` to scope results to just PrettyLittleThing's own label, a named sister brand, or any other brand sold on the site.
- **Rich product data:** current + original price, discount %, all available sizes, every colour variant with its own swatch image and stock, product description, material & care info
- **Fast and reliable:** hits PrettyLittleThing's own public product-search API directly — no browser rendering, no anti-bot friction
- **Empty fields are omitted** — every field returned actually has data

### Output per product

- `sku` — PrettyLittleThing's internal product code (e.g. `PLT100449`)
- `name` — product title
- `price` — current selling price (GBP)
- `originalPrice` — pre-discount price (only present when on sale)
- `discountPercentage`, `onSale`, `currency`
- `brand`, `collection`, `category`, `categories[]`, `categorySlugs[]`, `breadcrumbs[]`, `productType`, `department`, `gender`
- `length` — garment length (e.g. `Mini`, `Midi`, `Maxi`), `sleeveLength` (e.g. `Sleeveless`, `Long Sleeve`)
- `designTags[]`, `detailTags[]` — style/print/detail descriptors
- `aiAttributes` — AI-derived garment attributes (fit, neckline, material, pattern, etc.) when available
- `color` — primary colour family (e.g. `Pink`), `colorRaw` — exact shade name (e.g. `baby pink`), `colorFamily[]`
- `colorVariants[]` — every colour this product ships in, each with `color`, `swatchImageUrl`, `imageUrl`, `sizesInStock[]`, `isOnStock`
- `sizesAvailable[]` — every UK size currently in stock
- `imageUrl`, `images[]`, `swatchImageUrl`
- `productUrl` — canonical product page URL
- `ean`, `variantSkus[]`
- `isNew`, `isNextDay`, `isOnStock`, `isGift`, `giftWithPurchase`, `isBestseller`, `availableQuantity`, `validVariantCount`, `detailViews`
- `materialCare`, `description`, `occasion[]`, `season`
- `listedAt`, `lastUpdatedAt`
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` |
| `searchQuery` | string | `dress` | Free-text product search (mode=search) |
| `category` | string | `womens-dresses` | Category to browse (mode=byCategory) — dresses, tops, co-ords, denim, shoes, accessories, sale, and 30+ more |
| `size` | string | `any` | Only emit products available in this UK size |
| `color` | string | `any` | Only emit products in this colour family |
| `brand` | string | `any` | Only emit products from this brand (curated list of 30+ brands sold on prettylittlething.com) |
| `customBrand` | string | – | Any brand name not in the curated list, matched exactly (e.g. `Tommy Hilfiger`, `Gucci`). Overrides `brand` |
| `minPrice` | int | – | Drop products cheaper than this (GBP) |
| `maxPrice` | int | – | Drop products more expensive than this (GBP) |
| `onSaleOnly` | boolean | `false` | Only emit currently discounted products |
| `maxItems` | int | `50` | Hard cap on emitted records (1–500) |

#### Example: keyword search with size and price filter

```json
{
  "mode": "search",
  "searchQuery": "co-ord",
  "size": "10",
  "maxPrice": 35,
  "maxItems": 50
}
````

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

```json
{
  "mode": "byCategory",
  "category": "womens-dresses",
  "onSaleOnly": true,
  "maxItems": 100
}
```

#### Example: browse by category and colour

```json
{
  "mode": "byCategory",
  "category": "womens-tops",
  "color": "Black",
  "maxItems": 50
}
```

### Use cases

- **Price monitoring** — track current vs. original price and discount % across PrettyLittleThing's catalog
- **Trend research** — pull new-in and trending categories to spot emerging fashion trends
- **Competitor benchmarking** — compare PrettyLittleThing's assortment, pricing, and sizing against other fast-fashion retailers
- **Affiliate & dropshipping catalogs** — bulk-export product data with images and URLs
- **Size/stock availability tracking** — monitor which sizes are in stock for popular items

### FAQ

**What data source does this actor use?**
prettylittlething.com's own public product-search index, the same one that powers the site's search bar and category pages in your browser. No login or API key needed.

**Is this affiliated with PrettyLittleThing?**
No — this is an independent, third-party scraper that reads publicly accessible product data.

**How many categories are supported?**
40 curated categories covering the full womenswear range — clothing, dresses, tops, co-ords, denim, activewear, shoes, accessories, lingerie, plus size, petite, tall, and more. Use `mode=search` for anything outside the curated list.

**Why did I get fewer than `maxItems` records for a broad query?**
Algolia (the search backend prettylittlething.com uses) caps deep pagination at roughly 1,000 raw results per query (`page * hitsPerPage`), and results are de-duplicated by SKU as they're emitted. For very broad queries or categories with heavy internal duplication across promo collections, this can mean fewer than `maxItems` unique records even when `maxItems` is set high. Narrow the query (add `size`/`color`/`brand`/price filters) to raise the effective yield.

**Why is `originalPrice` sometimes missing?**
It's only included when the product is discounted. Full-price items only have `price`.

**Are prices in GBP?**
Yes — this actor scrapes the UK storefront (`www.prettylittlething.com`), so all prices are in GBP.

**How fresh is the data?**
Every run queries PrettyLittleThing's live product index directly, so pricing, stock, and sizes reflect the current state of the site.

**Why are some products missing colour or size data?**
A small number of listings (e.g. gift cards, one-size accessories) don't carry size/colour facets — those fields are simply omitted rather than shown as empty.

**Can I combine search with filters?**
Yes — `size`, `color`, `brand`, `minPrice`, `maxPrice`, and `onSaleOnly` all apply on top of both `search` and `byCategory` modes.

**Why does this scraper have a `brand` filter — isn't PrettyLittleThing its own brand?**
prettylittlething.com operates as a multi-brand marketplace under the hood: alongside its own house label it also fulfils orders for boohoo, KarenMillen, Coast, Wallis, Dorothy Perkins, Oasis, and 350+ other brands (fashion, beauty, and home). Every product returned by this actor is genuinely purchasable on prettylittlething.com — set `brand=PrettyLittleThing` if you only want the house label.

**Is PrettyLittleThing related to Boohoo?**
Yes, PrettyLittleThing is a sister brand under the Boohoo Group, but it operates as a separate storefront with its own catalog, pricing, and product codes — this actor scrapes prettylittlething.com independently.

# Actor input Schema

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

What to fetch.

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

Free-text product search (mode=search). E.g. `denim jacket`, `midi dress`, `bikini`.

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

Category to browse (mode=byCategory).

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

Only emit products available in this UK size.

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

Only emit products in this colour family.

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

PrettyLittleThing's storefront is a multi-brand marketplace (PrettyLittleThing house label plus boohoo, KarenMillen, Coast, Wallis, Dorothy Perkins, and 350+ other brands sold on prettylittlething.com). Only emit products from this brand. Use `customBrand` for any brand not in this curated list.

## `customBrand` (type: `string`):

Any brand name not in the curated `brand` list, matched exactly as it appears on prettylittlething.com (e.g. `Tommy Hilfiger`, `Gucci`, `Yankee Candle`). Overrides `brand` when set.

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

Drop products cheaper than this (current selling price, in GBP).

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

Drop products more expensive than this (current selling price, in GBP).

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

Only emit products currently discounted (markdown / sale price).

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "dress",
  "category": "womens-dresses",
  "size": "any",
  "color": "any",
  "brand": "any",
  "onSaleOnly": false,
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped PrettyLittleThing products.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQuery": "dress",
    "category": "womens-dresses",
    "size": "any",
    "color": "any",
    "brand": "any",
    "onSaleOnly": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/prettylittlething-fashion-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "searchQuery": "dress",
    "category": "womens-dresses",
    "size": "any",
    "color": "any",
    "brand": "any",
    "onSaleOnly": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/prettylittlething-fashion-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "searchQuery": "dress",
  "category": "womens-dresses",
  "size": "any",
  "color": "any",
  "brand": "any",
  "onSaleOnly": false,
  "maxItems": 50
}' |
apify call crawlerbros/prettylittlething-fashion-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PrettyLittleThing Fashion Scraper",
        "description": "Scrape prettylittlething.com fashion products. Search by keyword or browse any category (dresses, tops, co-ords, shoes, accessories, and more). Filter by size, colour, price, and sale status. Returns pricing, sizes, colours, images, and product URLs.",
        "version": "1.0",
        "x-build-id": "VM7VvVhZgwioypW6P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~prettylittlething-fashion-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-prettylittlething-fashion-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~prettylittlething-fashion-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-prettylittlething-fashion-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~prettylittlething-fashion-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-prettylittlething-fashion-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text product search (mode=search). E.g. `denim jacket`, `midi dress`, `bikini`.",
                        "default": "dress"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "womens-new-in",
                            "womens-clothing",
                            "womens-dresses",
                            "womens-tops",
                            "womens-co-ords",
                            "womens-coats-jackets-blazers",
                            "womens-bottoms",
                            "womens-coats-jackets",
                            "womens-skirts",
                            "womens-shorts",
                            "womens-shorts-jorts",
                            "womens-trousers",
                            "womens-athleisure",
                            "womens-activewear",
                            "womens-hoodies",
                            "womens-sweatshirts",
                            "womens-trousers-joggers",
                            "womens-tracksuits",
                            "womens-swimwear",
                            "womens-playsuits-jumpsuits-jumpsuits",
                            "womens-playsuits-jumpsuits-playsuits",
                            "womens-knitwear",
                            "womens-loungewear",
                            "womens-lingerie",
                            "womens-nightwear",
                            "womens-denim",
                            "womens-jeans",
                            "womens-plus-size",
                            "womens-petite",
                            "womens-shape",
                            "womens-tall",
                            "womens-shoes",
                            "womens-shoes-boots",
                            "womens-accessories",
                            "womens-accessories-bags",
                            "womens-accessories-jewellery",
                            "womens-sale",
                            "best-sellers",
                            "trending-now",
                            "womens-occasion-wedding"
                        ],
                        "type": "string",
                        "description": "Category to browse (mode=byCategory).",
                        "default": "womens-dresses"
                    },
                    "size": {
                        "title": "Size",
                        "enum": [
                            "any",
                            "4",
                            "6",
                            "8",
                            "10",
                            "12",
                            "14",
                            "16",
                            "18",
                            "20",
                            "22",
                            "24",
                            "26",
                            "28",
                            "30",
                            "32",
                            "34",
                            "36",
                            "38",
                            "40",
                            "42",
                            "44",
                            "46",
                            "XXS",
                            "XS",
                            "S",
                            "M",
                            "L",
                            "XL",
                            "XXL",
                            "2XL",
                            "3XL",
                            "4XL",
                            "5XL",
                            "6XL",
                            "One Size"
                        ],
                        "type": "string",
                        "description": "Only emit products available in this UK size.",
                        "default": "any"
                    },
                    "color": {
                        "title": "Colour",
                        "enum": [
                            "any",
                            "Black",
                            "Blue",
                            "Green",
                            "Pink",
                            "White",
                            "Brown",
                            "Red",
                            "Multi",
                            "Beige",
                            "Yellow",
                            "Navy",
                            "Purple",
                            "Orange",
                            "Grey",
                            "Cream",
                            "Khaki",
                            "Gold",
                            "Silver",
                            "Nude",
                            "Ecru",
                            "Metallics",
                            "Neutral",
                            "Clear",
                            "Coral",
                            "Rose Gold"
                        ],
                        "type": "string",
                        "description": "Only emit products in this colour family.",
                        "default": "any"
                    },
                    "brand": {
                        "title": "Brand",
                        "enum": [
                            "any",
                            "PrettyLittleThing",
                            "boohoo",
                            "KarenMillen",
                            "Coast",
                            "Wallis",
                            "Dorothy Perkins",
                            "DSGN Studio",
                            "NastyGal",
                            "Oasis",
                            "Linzi",
                            "AX Paris",
                            "Warehouse",
                            "Where's That From",
                            "Urban Bliss",
                            "EGO",
                            "MissPap",
                            "STEVE MADDEN",
                            "Femme Luxe",
                            "XY London",
                            "FS Collection",
                            "Goddiva",
                            "STYLEWISE",
                            "Pink Vanilla",
                            "Busem",
                            "Jon Richard",
                            "Dove",
                            "Dilvin",
                            "Public Desire",
                            "Moda Minx",
                            "TFNC London",
                            "Vesper",
                            "Ann Summers",
                            "Guess",
                            "Marc Jacobs"
                        ],
                        "type": "string",
                        "description": "PrettyLittleThing's storefront is a multi-brand marketplace (PrettyLittleThing house label plus boohoo, KarenMillen, Coast, Wallis, Dorothy Perkins, and 350+ other brands sold on prettylittlething.com). Only emit products from this brand. Use `customBrand` for any brand not in this curated list.",
                        "default": "any"
                    },
                    "customBrand": {
                        "title": "Custom brand (advanced)",
                        "type": "string",
                        "description": "Any brand name not in the curated `brand` list, matched exactly as it appears on prettylittlething.com (e.g. `Tommy Hilfiger`, `Gucci`, `Yankee Candle`). Overrides `brand` when set."
                    },
                    "minPrice": {
                        "title": "Min price (GBP)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (current selling price, in GBP)."
                    },
                    "maxPrice": {
                        "title": "Max price (GBP)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Drop products more expensive than this (current selling price, in GBP)."
                    },
                    "onSaleOnly": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Only emit products currently discounted (markdown / sale price).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
