# ASOS Scraper (`crawlerbros/asos-scraper`) Actor

Scrape ASOS (Europe's largest online fashion marketplace) with search by keyword, browse by category, fetch by product ID or URL, or check live stock and pricing. Returns names, brands, prices, sizes, images, descriptions, and stock per size across 10 markets (US, UK, DE, FR, IT, ES, AU, NL, SE, RU)

- **URL**: https://apify.com/crawlerbros/asos-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ASOS Scraper

Scrape **ASOS** — Europe's largest online fashion marketplace — for product
data across 10 country stores: United States, United Kingdom, France, Germany,
Italy, Spain, Australia, Netherlands, Sweden, and Russia.

Search by keyword, browse curated categories, look up products by ID or URL,
or check live stock + pricing snapshots. Returns names, brands, current and
discounted prices, sizes with per-size stock flags, images, video links, and
full product descriptions.

### Why this actor

- **No login, cookies, or proxy required** — runs on the free Apify plan.
- **10 markets** — country, currency, and language switch automatically.
- **Per-size stock** — see exactly which sizes are sold out before you buy.
- **Live discount % calculation** — compares current vs RRP / previous prices.
- **Five modes** in one actor — search, category browse, ID lookup, URL lookup,
  lightweight stock check.

### Modes

- **`search`** — free-text keyword search (e.g. `dress`, `levis jeans`,
  `nike air max`). The default mode.
- **`byCategory`** — browse a curated top-level category like
  *Women — Dresses* or *Men — Shoes*. Use the advanced `categoryId` field
  for any other ASOS category.
- **`byProductIds`** — fetch full product detail for a list of numeric ASOS
  product IDs (e.g. `210484705`).
- **`byUrls`** — fetch full product detail for a list of ASOS product URLs.
- **`stockCheck`** — lightweight snapshot of current stock + price per product
  ID; useful for daily price-monitor jobs.

### Filters

- **`store`** — US, GB, FR, DE, IT, ES, AU, NL, SE, RU
- **`currency`** — USD, GBP, EUR, AUD, SEK, RUB, CAD (or use the store default)
- **`gender`** — Women, Men, or All
- **`brandIds`**, **`colourIds`**, **`sizeIds`** — multi-select numeric IDs;
  inspect the `facets` block of any search response for the full mapping per
  category.
- **`sortBy`** — Recommended, Newest, Price low → high, Price high → low
- **`minPrice` / `maxPrice`** — price bounds in the active currency
- **`onSaleOnly`** — restrict to marked-down items
- **`inStockOnly`** — drop out-of-stock products (mainly useful with byProductIds / byUrls)
- **`containsKeyword`** — client-side substring filter across name / brand /
  colour / description
- **`includeDetails`** — for search and category modes, also fetch each PDP to
  get sizes, stock, description, etc.

### Input example

```json
{
  "mode": "search",
  "searchQuery": "dress",
  "store": "US",
  "currency": "USD",
  "gender": "women",
  "onSaleOnly": false,
  "inStockOnly": false,
  "maxItems": 15
}
````

Category browse:

```json
{
  "mode": "byCategory",
  "category": "women_dresses",
  "store": "GB",
  "minPrice": 20,
  "maxPrice": 80,
  "sortBy": "freshness",
  "maxItems": 50
}
```

Lookup by product ID:

```json
{
  "mode": "byProductIds",
  "productIds": ["210484705", "206776454"],
  "store": "US"
}
```

Live stock check:

```json
{
  "mode": "stockCheck",
  "productIds": ["210484705", "206776454"]
}
```

### Output fields

Each record is a flat JSON object with `recordType: "product"` (or `"stock"`
for stockCheck) and the following fields (any field with no value is omitted):

| Field | Description |
|---|---|
| `productId` | Numeric ASOS product ID |
| `productCode` | Vendor product code |
| `name` | Product name |
| `brand` | Brand name (e.g. `ASOS DESIGN`, `Levi's`) |
| `productType` | Product type (e.g. `Dresses`, `Shoes`) |
| `gender` | `Women` / `Men` |
| `colour` | Display colour name |
| `colourWayId` | Numeric colour-way ID |
| `totalColourways` | Number of colour-ways available |
| `currentPrice` | Current selling price (numeric) |
| `currentPriceFormatted` | Localized price string |
| `previousPrice` | Previous / strike-through price |
| `rrpPrice` | Manufacturer's RRP |
| `currency` | ISO 4217 currency code |
| `discountPercent` | Computed discount % vs previous / RRP |
| `isOnSale` | True if marked down |
| `isInStock` | True if at least one size is available |
| `isSellingFast` | ASOS "selling fast" flag |
| `isRestockingSoon` | ASOS "back soon" flag |
| `sizes` | Array `{ size, brandSize, variantId, sku, colour, price, isInStock, isLowInStock }` |
| `description` | Cleaned plain-text description |
| `descriptionPoints` | Bullet points extracted from the description |
| `countryOfManufacture` | Two-letter country code |
| `fitType` | Fit descriptor |
| `mainImageUrl` | Primary CDN image URL |
| `imageUrls` | All available CDN image URLs |
| `videoUrl` | Catwalk video URL (if any) |
| `productUrl` | Canonical PDP URL |
| `rating` | Average customer rating (if shown) |
| `reviewCount` | Total review count (if shown) |
| `recordType` | `product` or `stock` |
| `scrapedAt` | ISO 8601 UTC timestamp |

### FAQs

**Do I need to log in or supply cookies?**
No. ASOS exposes a public search API. The scraper fingerprints itself as
Chrome 131 and reaches the same endpoints the website uses.

**Does it work for all ASOS country stores?**
Ten stores are supported out of the box: US, GB, FR, DE, IT, ES, AU, NL, SE,
RU. Each store has its own catalog and currency; pick the one closest to
your audience.

**Can I get every size's stock state?**
Yes. The `sizes` array reports `isInStock` and `isLowInStock` per variant.
For search mode, set `includeDetails: true` to merge per-PDP stock into each
record; in `byProductIds` / `byUrls` modes this is on by default.

**How fresh is the data?**
ASOS updates pricing and stock continuously. Each record is timestamped with
`scrapedAt` so you can compute freshness from your snapshot.

**Where do the brand / colour / size IDs come from?**
They are ASOS's internal facet IDs. Run a search with no filters, inspect the
`facets` field of the raw response, and pick the IDs you need. The README's
Filters section documents the most common values.

**Can I use this to monitor prices?**
Yes — use the lightweight `stockCheck` mode on a list of product IDs to get
just the current price + stock per variant. It's much cheaper than full
detail mode.

### Data source

This actor scrapes the publicly accessible ASOS website
(`https://www.asos.com`). It uses the same JSON endpoints the ASOS web app
itself calls and parses the embedded product JSON from product pages — no
authenticated APIs, no third-party data brokers.

# Actor input Schema

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

What to fetch.

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

Free-text query (mode=search). Example: `dress`, `levis jeans`, `nike sneakers`.

## `store` (type: `string`):

ASOS country store. Currency defaults to the store's local currency unless overridden.

## `currency` (type: `string`):

Override the store's default currency. Leave blank to use the store default.

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

Restrict to the women's or men's edit (search/byCategory).

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

Pick one of ASOS's most-browsed top-level categories. Use `categoryId` for any other ASOS category ID.

## `categoryId` (type: `integer`):

Numeric ASOS category ID (e.g. 8799 = Dresses). Overrides `category` if set.

## `productIds` (type: `array`):

Numeric ASOS product IDs (5–12 digits). Example: `210484705`.

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

Full ASOS product URLs (must contain `/prd/<id>`).

## `brandIds` (type: `array`):

ASOS numeric brand IDs (e.g. `53` = ASOS DESIGN, `13511` = ASOS Curve, `16631` = ASOS Luxe, `27869` = ASOS Petite). Inspect the `Brand` facet of any search response for the full list.

## `colourIds` (type: `array`):

ASOS numeric colour IDs (e.g. `4` = Black, `10` = Brown, `17` = Multi, `2` = White, `7` = Green, `6` = Blue, `8` = Pink, `5` = Red, `3` = Grey, `11` = Beige).

## `sizeIds` (type: `array`):

ASOS numeric size IDs (e.g. `5131` = 2XS, `5179` = XS, `5180` = S, `5181` = M, `5182` = L, `5183` = XL). Inspect the `size` facet for the full mapping per category.

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

Result ordering.

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

Filter out products below this price (in the active currency).

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

Filter out products above this price (in the active currency).

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

Restrict to marked-down items.

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

Drop out-of-stock products (most useful with mode=byProductIds / byUrls; search hides OOS by default).

## `containsKeyword` (type: `string`):

Client-side substring filter applied to name / brand / colour / description.

## `includeDetails` (type: `boolean`):

For search / category modes, also fetch each product's PDP HTML to get sizes, stock, description, etc. Slower but richer. Already on for byProductIds / byUrls.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "dress",
  "store": "US",
  "currency": "",
  "gender": "",
  "category": "",
  "productIds": [],
  "productUrls": [],
  "brandIds": [],
  "colourIds": [],
  "sizeIds": [],
  "sortBy": "",
  "onSaleOnly": false,
  "inStockOnly": false,
  "includeDetails": false,
  "maxItems": 15
}
```

# Actor output Schema

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

Dataset containing all scraped ASOS 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",
    "store": "US",
    "productIds": [],
    "productUrls": [],
    "onSaleOnly": false,
    "inStockOnly": false,
    "includeDetails": false,
    "maxItems": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/asos-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",
    "store": "US",
    "productIds": [],
    "productUrls": [],
    "onSaleOnly": False,
    "inStockOnly": False,
    "includeDetails": False,
    "maxItems": 15,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/asos-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",
  "store": "US",
  "productIds": [],
  "productUrls": [],
  "onSaleOnly": false,
  "inStockOnly": false,
  "includeDetails": false,
  "maxItems": 15
}' |
apify call crawlerbros/asos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ASOS Scraper",
        "description": "Scrape ASOS (Europe's largest online fashion marketplace) with search by keyword, browse by category, fetch by product ID or URL, or check live stock and pricing. Returns names, brands, prices, sizes, images, descriptions, and stock per size across 10 markets (US, UK, DE, FR, IT, ES, AU, NL, SE, RU)",
        "version": "1.0",
        "x-build-id": "jLpDBevPLPcIDgdkw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~asos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-asos-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~asos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-asos-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~asos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-asos-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",
                            "byProductIds",
                            "byUrls",
                            "stockCheck"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query (mode=search). Example: `dress`, `levis jeans`, `nike sneakers`.",
                        "default": "dress"
                    },
                    "store": {
                        "title": "Store / market",
                        "enum": [
                            "US",
                            "GB",
                            "FR",
                            "DE",
                            "IT",
                            "ES",
                            "AU",
                            "NL",
                            "SE",
                            "RU"
                        ],
                        "type": "string",
                        "description": "ASOS country store. Currency defaults to the store's local currency unless overridden.",
                        "default": "US"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "",
                            "USD",
                            "GBP",
                            "EUR",
                            "AUD",
                            "SEK",
                            "RUB",
                            "CAD"
                        ],
                        "type": "string",
                        "description": "Override the store's default currency. Leave blank to use the store default.",
                        "default": ""
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "",
                            "women",
                            "men"
                        ],
                        "type": "string",
                        "description": "Restrict to the women's or men's edit (search/byCategory).",
                        "default": ""
                    },
                    "category": {
                        "title": "Curated category (mode=byCategory)",
                        "enum": [
                            "",
                            "women_new_in_clothing",
                            "women_dresses",
                            "women_tops",
                            "women_shirts",
                            "women_shoes",
                            "women_jeans",
                            "women_accessories",
                            "women_activewear",
                            "men_new_in_clothing",
                            "men_tops",
                            "men_shirts",
                            "men_shoes",
                            "men_jeans",
                            "men_accessories"
                        ],
                        "type": "string",
                        "description": "Pick one of ASOS's most-browsed top-level categories. Use `categoryId` for any other ASOS category ID.",
                        "default": ""
                    },
                    "categoryId": {
                        "title": "Category ID (advanced override)",
                        "minimum": 1,
                        "maximum": 999999,
                        "type": "integer",
                        "description": "Numeric ASOS category ID (e.g. 8799 = Dresses). Overrides `category` if set."
                    },
                    "productIds": {
                        "title": "Product IDs (mode=byProductIds, stockCheck)",
                        "type": "array",
                        "description": "Numeric ASOS product IDs (5–12 digits). Example: `210484705`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=byUrls)",
                        "type": "array",
                        "description": "Full ASOS product URLs (must contain `/prd/<id>`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandIds": {
                        "title": "Brand IDs",
                        "type": "array",
                        "description": "ASOS numeric brand IDs (e.g. `53` = ASOS DESIGN, `13511` = ASOS Curve, `16631` = ASOS Luxe, `27869` = ASOS Petite). Inspect the `Brand` facet of any search response for the full list.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "colourIds": {
                        "title": "Colour IDs",
                        "type": "array",
                        "description": "ASOS numeric colour IDs (e.g. `4` = Black, `10` = Brown, `17` = Multi, `2` = White, `7` = Green, `6` = Blue, `8` = Pink, `5` = Red, `3` = Grey, `11` = Beige).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sizeIds": {
                        "title": "Size IDs",
                        "type": "array",
                        "description": "ASOS numeric size IDs (e.g. `5131` = 2XS, `5179` = XS, `5180` = S, `5181` = M, `5182` = L, `5183` = XL). Inspect the `size` facet for the full mapping per category.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort",
                        "enum": [
                            "",
                            "freshness",
                            "priceasc",
                            "pricedesc"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Filter out products below this price (in the active currency)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Filter out products above this price (in the active currency)."
                    },
                    "onSaleOnly": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Restrict to marked-down items.",
                        "default": false
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Drop out-of-stock products (most useful with mode=byProductIds / byUrls; search hides OOS by default).",
                        "default": false
                    },
                    "containsKeyword": {
                        "title": "Contains keyword",
                        "type": "string",
                        "description": "Client-side substring filter applied to name / brand / colour / description."
                    },
                    "includeDetails": {
                        "title": "Include full product details",
                        "type": "boolean",
                        "description": "For search / category modes, also fetch each product's PDP HTML to get sizes, stock, description, etc. Slower but richer. Already on for byProductIds / byUrls.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
