# Reebok Scraper (`solidcode/reebok-scraper`) Actor

\[💰 $2.5 / 1K] Scrape Reebok.com products: name, price, discount, rating, colorways, sizes, images and stock. Search by keyword or paste a Reebok collection, category, or search URL. Filter by gender and sale, sort results. Built for retail analysts tracking pricing, catalogs, and promotions.

- **URL**: https://apify.com/solidcode/reebok-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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

## Reebok Scraper

Pull the full Reebok.com product catalog at scale — prices, markdowns, ratings, colorways, size runs, images, and stock status for every shoe, apparel item, and accessory. Search by keyword or paste any Reebok collection, category, or search URL, then narrow by audience and sort however the site does. Built for retail pricing analysts, resellers, and e-commerce competitor-monitoring teams who need fresh Reebok catalog and promotion data without hand-building URLs or babysitting a scraper.

### Why This Scraper?

- **Keyword search and direct URLs in one run** — type "running shoes" for an instant Reebok.com search, or paste any collection/category/search URL. Your gender, sort, and On-Sale-Only choices apply to both. Mix sources in a single run.
- **Four audience segments** — narrow any keyword search or pasted URL to Men, Women, Kids, or Unisex, or leave it on Any to sweep the whole catalog.
- **Four sort modes** — Most Relevant, Price: low to high, Price: high to low, and Best Selling, matching Reebok's own storefront ordering.
- **Full colorway variant array on every product** — each colorway carries its own title, price, original price, image, product URL, sale badge, and in-stock flag, so you capture every variation, not just the default swatch.
- **Per-size availability** — the exact size run (e.g. US 4 through 13) offered for each product's primary colorway, straight from the listing.
- **Three-part pricing on every row** — current price, compare-at (regular) price, and a computed discount percentage, so markdown depth is a number you can sort and filter on.
- **On-Sale-Only filter** — return only products with an active markdown (sale price below regular), applied across both keyword and URL inputs.
- **Aggregate star rating and review count** — a 0–5 rating and total review count on every reviewed product, ready for social-proof ranking.
- **24 clean camelCase fields per product** — including model number, marketing division (Classics, Training, Running, Golf), category, product type, currency, and a full image gallery.

### Use Cases

**Price & Promotion Monitoring**
- Track sale price, regular price, and discount percentage on any Reebok line day over day
- Flag new markdowns with the On-Sale-Only filter and Price: low to high sort
- Watch discount depth across colorways of the same silhouette
- Build alerts for price drops on the styles you care about

**Competitor & Market Research**
- Benchmark Reebok pricing against your own catalog by category and audience
- Map assortment breadth across Men, Women, Kids, and Unisex segments
- Compare rating and review counts to gauge which styles have traction
- Trend Reebok's promotional cadence across collections over time

**Reselling & Arbitrage**
- Surface the deepest markdowns in one audience by combining gender, On-Sale-Only, and Price: low to high
- Capture per-size availability to spot in-demand sizes before they sell out
- Track colorway-level pricing to find the cheapest variant of a hot model
- Pull model numbers to cross-reference resale values on secondary marketplaces

**Catalog & Assortment**
- Export an entire collection (e.g. /collections/mens-shoes) with one pasted URL
- Enrich a product database with images, sizes, colorways, and division labels
- Feed clean, camelCase product rows into dashboards and BI tools
- Keep an offline mirror of the Reebok catalog with fresh timestamps

**Inventory & Stock Tracking**
- Monitor the in-stock flag on products and individual colorways
- Detect when sold-out sizes come back into the size run
- Track which variants of a style are available across audiences
- Prioritize restock outreach using rating and review signals

### Getting Started

#### Simple Keyword Search

The fastest way to start — one keyword, capped for a quick test:

```json
{
    "searchQueries": ["running shoes"],
    "maxItemsPerInput": 50
}
````

#### Scrape a Full Collection

Paste any Reebok collection URL to pull it exactly as the site curates it:

```json
{
    "startUrls": ["https://www.reebok.com/collections/mens-shoes"],
    "maxItemsPerInput": 100
}
```

#### Full-Featured Example

Combine keywords, an audience, a sale filter, and a price sort:

```json
{
    "searchQueries": ["classic leather", "club c"],
    "gender": "women",
    "onSaleOnly": true,
    "sortBy": "priceAsc",
    "maxItemsPerInput": 200
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["running shoes"]` | Keywords to search on Reebok.com — each runs its own search, no URL needed. Leave empty if you only use Start URLs. |
| `startUrls` | array | `[]` | Reebok collection, category, or search URLs pasted directly (e.g. `https://www.reebok.com/collections/kids`). Your gender, sort, and On-Sale-Only choices apply on top of each URL. Individual product pages are not supported. |

#### Filters

Filters below apply to both keyword searches and pasted Start URLs.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `gender` | string | `Any` | Narrow results to one audience: Any, Men, Women, Kids, or Unisex. Applies to keywords and URLs alike. |
| `onSaleOnly` | boolean | `false` | When on, return only products with an active discount. Applies to keywords and URLs alike. |
| `sortBy` | string | `Most Relevant` | Order results: Most Relevant, Price: low to high, Price: high to low, or Best Selling. Applies to keywords and URLs alike. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItemsPerInput` | integer | `100` | Maximum products per keyword or Start URL. Set to `0` for unlimited. Start with 20–50 to test, then increase. |

### Output

Each product is one flat row. Here is a representative result:

```json
{
    "productId": "100033874",
    "name": "Classic Leather Shoes",
    "modelNumber": "100033874",
    "brand": "Reebok",
    "category": "Shoes",
    "productType": "Lifestyle",
    "gender": "Unisex",
    "division": "Classics",
    "price": 74.99,
    "originalPrice": 90.00,
    "currency": "USD",
    "discountPercentage": 17,
    "onSale": true,
    "inStock": true,
    "rating": 4.6,
    "reviewCount": 1284,
    "color": "Chalk / Paperwhite / Pure Grey",
    "sizes": ["5", "6", "7", "8", "9", "10", "11", "12", "13"],
    "image": "https://www.reebok.com/cdn/shop/files/Classic_Leather_White.jpg",
    "images": [
        "https://www.reebok.com/cdn/shop/files/Classic_Leather_White_1.jpg",
        "https://www.reebok.com/cdn/shop/files/Classic_Leather_White_2.jpg"
    ],
    "badge": "Sale",
    "variants": [
        {
            "variantTitle": "Core Black / Core Black / Pure Grey",
            "price": 90.00,
            "originalPrice": null,
            "image": "https://www.reebok.com/cdn/shop/files/Classic_Leather_Black.jpg",
            "url": "https://www.reebok.com/products/classic-leather-shoes-black",
            "badge": null,
            "inStock": true
        }
    ],
    "url": "https://www.reebok.com/products/classic-leather-shoes",
    "scrapedAt": "2026-07-11T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | Unique Reebok product identifier |
| `name` | string | Product name |
| `modelNumber` | string | Reebok article / model number |
| `brand` | string | Brand or sub-brand (usually "Reebok") |
| `category` | string | Product category (e.g. Shoes, Apparel, Accessories) |
| `productType` | string | Product type or line |
| `gender` | string | Target audience (Men, Women, Kids, Unisex) |
| `division` | string | Marketing division (Classics, Training, Running, Golf) |
| `url` | string | Direct product page URL |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

#### Pricing & Availability

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Current (sale) price |
| `originalPrice` | number | Regular price before discount, when on sale |
| `currency` | string | ISO currency code (e.g. USD) |
| `discountPercentage` | number | Percent off, when discounted |
| `onSale` | boolean | True when the price is below the regular price |
| `inStock` | boolean | Whether the product is currently available |
| `badge` | string | Listing badge (e.g. "Sale") |

#### Ratings

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Aggregate star rating (0–5) |
| `reviewCount` | integer | Total number of reviews |

#### Variants, Sizes & Images

| Field | Type | Description |
|-------|------|-------------|
| `color` | string | Primary colorway name |
| `sizes` | array | Available sizes for the primary colorway |
| `image` | string | Main product image URL |
| `images` | array | Additional product image URLs |
| `variants` | array | Colorway variants, each with `variantTitle`, `price`, `originalPrice`, `image`, `url`, `badge`, and `inStock` |

### Tips for Best Results

- **Start small, then scale** — set `maxItemsPerInput` to 20–50 on your first run to confirm the data fits your needs, then raise it or set `0` for unlimited.
- **Hunt promos like a pro** — combine `gender`, `onSaleOnly`, and `sortBy` set to Price: low to high to surface the deepest markdowns for one audience in a single run.
- **Use collection URLs for exact category coverage** — pasting a URL like `/collections/kids` reproduces Reebok's own curation more precisely than a broad keyword, then layer gender, sort, or On-Sale-Only on top.
- **Filters layer onto URLs too** — `gender`, `sortBy`, and `onSaleOnly` shape pasted Start URLs just like keyword searches, so you can price-sort or audience-narrow a collection URL without rebuilding it by hand.
- **Mind contradictory pairings** — an already-audience-scoped URL (e.g. `/collections/mens-shoes`) combined with a different `gender` returns their intersection, which can legitimately be few or zero rows — pick a neutral collection when layering a gender.
- **Paste collections, not products** — Start URLs must be collection, category, or search pages; individual product pages are skipped with a clear note.
- **Mine the `variants` array** — colorway-level pricing and stock live there, so the cheapest or last-available variant of a model is often a variant, not the top-level row.

### Pricing

**From $2.50 per 1,000 results** — roughly half the going rate for Reebok catalog data. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is one product row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

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

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

### Legal & Ethical Use

This actor is designed for legitimate retail research, price monitoring, and market analysis of publicly available product listings. You are responsible for complying with applicable laws and Reebok's Terms of Service. Do not use extracted data for any unlawful, deceptive, or infringing purpose. Collect only public catalog data and use it responsibly.

# Actor input Schema

## `searchQueries` (type: `array`):

Type what you're looking for on Reebok, e.g. 'running shoes' or 'classic leather'. Each keyword runs its own search on reebok.com — no need to build a URL. Leave empty if you only use Start URLs below.

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

Paste Reebok collection, category, or search URLs directly, e.g. https://www.reebok.com/collections/mens-shoes or https://www.reebok.com/collections/kids. The Gender, Sort, and On Sale Only settings below are applied on top of each URL. Individual product pages are not supported.

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

Narrow results to one audience. Applies to both Search Keywords and pasted Start URLs. Leave as 'Any' to include everything.

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

When on, only products with an active discount (a sale price below the regular price) are returned. Applies to every product, from keywords and URLs alike.

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

Order in which results are collected. Applies to both Search Keywords and pasted Start URLs.

## `maxItemsPerInput` (type: `integer`):

Maximum number of products to collect per search keyword or Start URL. Set to 0 for unlimited (collects every product the search or collection returns). Tip: start with 20-50 to test, then increase.

## Actor input object example

```json
{
  "searchQueries": [
    "running shoes"
  ],
  "startUrls": [],
  "gender": "any",
  "onSaleOnly": false,
  "sortBy": "relevance",
  "maxItemsPerInput": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of products with key fields: name, brand, gender, category, price, rating, and image.

## `pricing` (type: `string`):

Current price, original price, discount, sale flag, and stock for each product.

# 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 = {
    "searchQueries": [
        "running shoes"
    ],
    "startUrls": [],
    "gender": "any",
    "onSaleOnly": false,
    "sortBy": "relevance",
    "maxItemsPerInput": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/reebok-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 = {
    "searchQueries": ["running shoes"],
    "startUrls": [],
    "gender": "any",
    "onSaleOnly": False,
    "sortBy": "relevance",
    "maxItemsPerInput": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/reebok-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 '{
  "searchQueries": [
    "running shoes"
  ],
  "startUrls": [],
  "gender": "any",
  "onSaleOnly": false,
  "sortBy": "relevance",
  "maxItemsPerInput": 100
}' |
apify call solidcode/reebok-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reebok Scraper",
        "description": "[💰 $2.5 / 1K] Scrape Reebok.com products: name, price, discount, rating, colorways, sizes, images and stock. Search by keyword or paste a Reebok collection, category, or search URL. Filter by gender and sale, sort results. Built for retail analysts tracking pricing, catalogs, and promotions.",
        "version": "1.0",
        "x-build-id": "chP0fQCrllTQMHFx7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~reebok-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-reebok-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~reebok-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-reebok-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~reebok-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-reebok-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Type what you're looking for on Reebok, e.g. 'running shoes' or 'classic leather'. Each keyword runs its own search on reebok.com — no need to build a URL. Leave empty if you only use Start URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste Reebok collection, category, or search URLs directly, e.g. https://www.reebok.com/collections/mens-shoes or https://www.reebok.com/collections/kids. The Gender, Sort, and On Sale Only settings below are applied on top of each URL. Individual product pages are not supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "any",
                            "men",
                            "women",
                            "kids",
                            "unisex"
                        ],
                        "type": "string",
                        "description": "Narrow results to one audience. Applies to both Search Keywords and pasted Start URLs. Leave as 'Any' to include everything.",
                        "default": "any"
                    },
                    "onSaleOnly": {
                        "title": "On Sale Only",
                        "type": "boolean",
                        "description": "When on, only products with an active discount (a sale price below the regular price) are returned. Applies to every product, from keywords and URLs alike.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "bestSelling"
                        ],
                        "type": "string",
                        "description": "Order in which results are collected. Applies to both Search Keywords and pasted Start URLs.",
                        "default": "relevance"
                    },
                    "maxItemsPerInput": {
                        "title": "Max Products per Search or URL",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to collect per search keyword or Start URL. Set to 0 for unlimited (collects every product the search or collection returns). Tip: start with 20-50 to test, then increase.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
