# Musinsa Fashion Rankings Scraper (`automation-lab/musinsa-fashion-rankings-scraper`) Actor

🏆 Export current Musinsa product rankings with brands, KRW prices, discounts, reviews, labels, and audience filters for repeat K-fashion intelligence.

- **URL**: https://apify.com/automation-lab/musinsa-fashion-rankings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## Musinsa Fashion Rankings Scraper

Export current **Musinsa fashion rankings** as clean, structured data. Track which products and brands are moving on Korea's leading fashion marketplace, compare KRW prices and discounts, and schedule repeat snapshots without running a browser.

This Actor reads Musinsa's public ranking data and saves one dataset row per ranked product. Every result includes source and filter context, so analysts can compare snapshots confidently.

### What does Musinsa Fashion Rankings Scraper do?

It turns Musinsa's live product-ranking modules into export-ready records.

- 🏆 Collect rank, product ID, product name, and product URL.
- 🏷️ Capture brand ID, brand name, and brand URL.
- 💸 Compare original price, final price, discount amount, and discount rate in KRW.
- ⭐ Export review count and review score when Musinsa supplies them.
- 🔥 Preserve labels plus live viewer or buyer snippets.
- 🧭 Apply category, gender, age-band, period, and sold-out filters.
- 📅 Add a scrape timestamp and complete filter context to every row.

### Who is it for?

**K-fashion brands** can monitor whether their products enter or leave important category rankings.

**Retailers and resellers** can identify fast-moving products and discounts before making buying decisions.

**Merchandisers** can compare audience segments, category leaders, and price bands.

**Market-research teams** can schedule snapshots and build historical trend datasets.

**Data teams** can feed structured Musinsa ranking data into warehouses, dashboards, spreadsheets, or alerting systems.

### Why use this Musinsa ranking scraper?

Musinsa's ranking page is useful for shoppers but not designed for repeated analysis. Copying records manually is slow, inconsistent, and difficult to automate.

This Actor gives you:

- consistent field names across runs;
- strict `maxItems` cost control;
- deduplication by Musinsa product ID;
- source URLs for auditability;
- JSON, CSV, Excel, XML, RSS, and API access through Apify datasets;
- fail-closed behavior when a requested ranking signal is unavailable.

### What Musinsa data can I extract?

| Field | Meaning |
|---|---|
| `rank` | Position shown by Musinsa |
| `productId` | Stable Musinsa product identifier |
| `productName` | Product title |
| `productUrl` | Canonical product page |
| `brandId` | Musinsa brand identifier |
| `brandName` | Displayed Korean brand name |
| `brandUrl` | Brand page when provided |
| `imageUrl` | Product image |
| `currency` | `KRW` |
| `originalPrice` | Price before discount |
| `finalPrice` | Current displayed price |
| `discountAmount` | Calculated original minus final price |
| `discountRate` | Displayed discount percentage |
| `reviewCount` | Number of reviews |
| `reviewScore` | Musinsa review score |
| `soldOut` | Whether the card is sold out |
| `labels` | Product and sales labels |
| `salesSnippets` | Live viewing or buying text |
| `categoryId` | Applied category identifier |
| `appliedTab` | Ranking tab reported by Musinsa |
| `filters` | Exact run filter context |
| `sourceUrl` | Public JSON URL used for the row |
| `scrapedAt` | UTC extraction timestamp |

### Supported ranking modes

Set `rankingType` to one of:

- `overall` — request Musinsa's page-advertised overall source section (`199`);
- `new` — request the distinct NEW source section (`200`);
- `rising` — request the distinct rising source section (`201`).

Every row must match both the selected source URL and that source's applied-tab signal. The Actor never treats a label or shared tab value from an overall feed as proof that a product is a new arrival.

### Category filters

The Actor selects the source section from `rankingType`. The default `categoryCode` is `000`, meaning all categories.

Common main-store category codes include:

- `001` — tops;
- `002` — outerwear;
- `003` — pants;
- `004` — bags;
- `100` — dresses and skirts;
- `005` — fashion accessories;
- `018` — sneakers;
- `104` — beauty.

Musinsa controls these identifiers. Use category codes advertised on the current ranking page.

### Audience and period filters

Choose all, men, or women with `gender`. Segment rankings by all ages, under 20, five-year age bands from 20 through 39, or 40+.

Use `period` for real-time, daily, weekly, or monthly ranking windows. The returned `filters` object records the exact choice in every result.

### How to scrape Musinsa rankings

1. Open the Actor input page.
2. Choose an overall, new, or rising ranking.
3. Keep category `000` for a broad first run.
4. Optionally select gender, age band, period, and sold-out behavior.
5. Set a low `maxItems` while testing.
6. Click **Start**.
7. Open the dataset and export in your preferred format.

### Input example

```json
{
  "rankingType": "overall",
  "categoryCode": "001",
  "gender": "F",
  "ageBand": "AGE_BAND_25",
  "period": "WEEKLY",
  "includeSoldOut": false,
  "maxItems": 50
}
````

### Output example

```json
{
  "rank": 1,
  "productId": "6064531",
  "productName": "Example ranked product",
  "productUrl": "https://www.musinsa.com/products/6064531",
  "brandId": "example-brand",
  "brandName": "예시 브랜드",
  "currency": "KRW",
  "originalPrice": 69000,
  "finalPrice": 34500,
  "discountAmount": 34500,
  "discountRate": 50,
  "reviewCount": 104,
  "reviewScore": 98,
  "soldOut": false,
  "labels": [],
  "salesSnippets": ["207명이 보는 중"],
  "filters": {
    "rankingType": "overall",
    "sectionId": "199",
    "categoryCode": "001",
    "gender": "F",
    "ageBand": "AGE_BAND_25",
    "period": "WEEKLY",
    "includeSoldOut": false
  },
  "scrapedAt": "2026-07-19T07:00:00.000Z"
}
```

Actual products and values change as Musinsa updates its rankings.

### How much does it cost to scrape Musinsa rankings?

This Actor uses pay-per-event pricing: a small fee when a run starts and a tiered fee for each saved ranking product. Higher Apify plans receive lower per-product prices.

The default input saves only 30 products, while the input form prefill uses 10 for a cheap first test. Check the live Actor pricing tab for the exact price attached to your Apify plan.

### Scheduling a Musinsa ranking monitor

Create an Apify schedule to run the same input hourly, daily, or weekly. Export each run to a warehouse or use dataset webhooks to notify another system.

A useful monitoring key is `productId`. Compare rank, final price, discount rate, labels, and sold-out state between snapshots.

### Trend-analysis workflow

For category trend analysis:

1. run one category per schedule;
2. keep gender and age filters stable;
3. store `scrapedAt` and `filters` with every row;
4. calculate rank movement by `productId`;
5. aggregate brand share by `brandId`;
6. alert when a product enters the top 10 or its discount changes.

### Price-intelligence workflow

Use `originalPrice`, `finalPrice`, `discountAmount`, and `discountRate` together. A ranking snapshot can reveal price bands and promotion intensity without visiting each product detail page.

The Actor reports the price shown on the ranking card. It does not calculate delivery fees, member-only coupons, or checkout totals.

### Apify integrations

Connect results to:

- **Google Sheets** for buyer and merchandising reviews;
- **Slack** for top-10 or rising-product alerts;
- **Make** or **Zapier** for no-code workflows;
- **webhooks** for immediate post-run processing;
- **Amazon S3** or **Google Drive** for snapshot archives;
- **BigQuery**, **Snowflake**, or another warehouse for historical analysis.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/musinsa-fashion-rankings-scraper').call({
  rankingType: 'overall',
  categoryCode: '001',
  gender: 'F',
  period: 'REALTIME',
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/musinsa-fashion-rankings-scraper').call(run_input={
    'rankingType': 'overall',
    'categoryCode': '000',
    'period': 'WEEKLY',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~musinsa-fashion-rankings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"rankingType":"overall","categoryCode":"000","maxItems":30}'
```

### Use with Apify MCP

Connect the Actor to AI assistants through Apify MCP.

**Claude Code setup:**

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/musinsa-fashion-rankings-scraper"
```

**Claude Desktop setup:** add this server to the Claude Desktop MCP configuration.

**Cursor setup:** add the same HTTP URL in Cursor Settings → MCP.

**VS Code setup:** add the same HTTP URL to your workspace MCP server configuration.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/musinsa-fashion-rankings-scraper"
    }
  }
}
```

Example prompts:

- “Export the top 30 Musinsa women's tops and summarize the leading brands.”
- “Compare weekly discounts in the overall Musinsa ranking.”
- “Create a table of rank, product, brand, KRW price, and review count.”

### Data quality and reliability

The Actor maps each ranking mode to its page-advertised source section and validates category identifiers before sending a request. It fails non-zero if Musinsa returns no matching product cards, preventing a structural source change from looking like a successful empty scrape.

Products are deduplicated by `productId`. Sequential requests and strict item limits reduce unnecessary load.

### Limitations

- Musinsa can change its public modules, category IDs, labels, or ranking logic.
- Source section IDs and applied-tab names can change if Musinsa redesigns rankings.
- Review fields may be absent on some cards.
- Ranking-card prices may differ from checkout prices or targeted coupons.
- The Actor exports rankings, not complete product detail pages or inventory variants.
- Korean labels and product names are preserved as supplied.

### Tips for best results

- Start with `overall` and category `000`.
- Test unknown category codes with a small `maxItems`.
- Keep filter settings fixed when comparing snapshots.
- Use product IDs, not translated names, as historical keys.
- Schedule weekly mode weekly and real-time mode more frequently.
- Store raw labels because Musinsa may introduce new popularity signals.

### Is scraping Musinsa legal?

This Actor accesses publicly available ranking data without logging in. Web scraping laws and website terms vary by jurisdiction and use case.

You are responsible for using the data lawfully, respecting applicable terms, intellectual-property rights, privacy obligations, and reasonable request rates. Do not use the Actor to collect private account data or bypass access controls.

### Troubleshooting

#### Why did a new or rising run fail with no matching products?

Musinsa did not return cards carrying the expected source-tab signal for that page-advertised route. Try a broader category or another period. The failure is intentional and avoids misleading output.

#### Why did a category return no records?

Confirm the `categoryCode` is currently advertised by Musinsa for the selected ranking type. Category availability can differ between Overall, NEW, and Rising tabs.

#### Why are some review or brand fields missing?

Musinsa does not include every optional field on every product card. The Actor preserves available values rather than inventing defaults.

### FAQ

#### Does the Actor require a Musinsa account?

No. The supported ranking scope is public and anonymous.

#### Does it run a browser?

No. It uses the JSON data route advertised by Musinsa's ranking page, so it is faster and cheaper than browser automation.

#### Can it return more than 100 products?

Yes, when Musinsa supplies a next link for the selected ranking. `maxItems` is capped at 500 to keep runs bounded.

#### Can I translate Korean names automatically?

The Actor preserves source text for accuracy. Translate downstream with your preferred translation service.

#### Can it scrape full product details or variants?

No. Version 1 focuses on ranking intelligence. Product URLs and IDs can feed a separate product-detail workflow.

#### How fresh are the results?

Freshness follows the selected Musinsa period and Musinsa's own ranking update schedule. `scrapedAt` records when this Actor fetched the snapshot.

### Related scrapers

Combine ranking data with other Automation Lab actors when you need broader research:

- [Google Search Results Scraper](https://apify.com/automation-lab/google-search-scraper) for open-web brand research.
- [Website Screenshot Generator](https://apify.com/automation-lab/website-screenshot-generator) for visual monitoring of public pages.
- [URL Metadata Extractor](https://apify.com/automation-lab/url-metadata-extractor) for enriching product and brand links.

Check each related Actor's current Store page and input contract before building a workflow.

### Support

If a run fails, share the run ID, non-sensitive input, selected section/category codes, and the relevant log message through the Actor's Issues tab. This makes source changes faster to diagnose.

# Actor input Schema

## `rankingType` (type: `string`):

Selects Musinsa's distinct Overall, NEW, or Rising source ranking tab. Results must match both that source route and its tab signal.

## `categoryCode` (type: `string`):

Musinsa category code. Use 000 for all products, 001 for tops, 002 for outerwear, or another page-advertised code.

## `contentsId` (type: `string`):

Optional page-advertised content group ID for outlet or kids sections.

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

Audience segment used by Musinsa rankings.

## `ageBand` (type: `string`):

Age segment used in Musinsa's ranking calculation.

## `period` (type: `string`):

Time window for the ranking snapshot.

## `includeSoldOut` (type: `boolean`):

Keep sold-out products in the source ranking.

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

Strict maximum number of ranked products to save.

## Actor input object example

```json
{
  "rankingType": "overall",
  "categoryCode": "000",
  "contentsId": "",
  "gender": "A",
  "ageBand": "AGE_BAND_ALL",
  "period": "REALTIME",
  "includeSoldOut": true,
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "rankingType": "overall",
    "categoryCode": "000",
    "gender": "A",
    "ageBand": "AGE_BAND_ALL",
    "period": "REALTIME",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/musinsa-fashion-rankings-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 = {
    "rankingType": "overall",
    "categoryCode": "000",
    "gender": "A",
    "ageBand": "AGE_BAND_ALL",
    "period": "REALTIME",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/musinsa-fashion-rankings-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 '{
  "rankingType": "overall",
  "categoryCode": "000",
  "gender": "A",
  "ageBand": "AGE_BAND_ALL",
  "period": "REALTIME",
  "maxItems": 10
}' |
apify call automation-lab/musinsa-fashion-rankings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Musinsa Fashion Rankings Scraper",
        "description": "🏆 Export current Musinsa product rankings with brands, KRW prices, discounts, reviews, labels, and audience filters for repeat K-fashion intelligence.",
        "version": "0.1",
        "x-build-id": "skrBp7i610aooWkJe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~musinsa-fashion-rankings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-musinsa-fashion-rankings-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/automation-lab~musinsa-fashion-rankings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-musinsa-fashion-rankings-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/automation-lab~musinsa-fashion-rankings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-musinsa-fashion-rankings-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": {
                    "rankingType": {
                        "title": "🏆 Ranking type",
                        "enum": [
                            "overall",
                            "new",
                            "rising"
                        ],
                        "type": "string",
                        "description": "Selects Musinsa's distinct Overall, NEW, or Rising source ranking tab. Results must match both that source route and its tab signal.",
                        "default": "overall"
                    },
                    "categoryCode": {
                        "title": "Category code",
                        "type": "string",
                        "description": "Musinsa category code. Use 000 for all products, 001 for tops, 002 for outerwear, or another page-advertised code.",
                        "default": "000"
                    },
                    "contentsId": {
                        "title": "Contents ID",
                        "type": "string",
                        "description": "Optional page-advertised content group ID for outlet or kids sections.",
                        "default": ""
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "A",
                            "M",
                            "F"
                        ],
                        "type": "string",
                        "description": "Audience segment used by Musinsa rankings.",
                        "default": "A"
                    },
                    "ageBand": {
                        "title": "Age band",
                        "enum": [
                            "AGE_BAND_ALL",
                            "AGE_BAND_MINOR",
                            "AGE_BAND_20",
                            "AGE_BAND_25",
                            "AGE_BAND_30",
                            "AGE_BAND_35",
                            "AGE_BAND_40"
                        ],
                        "type": "string",
                        "description": "Age segment used in Musinsa's ranking calculation.",
                        "default": "AGE_BAND_ALL"
                    },
                    "period": {
                        "title": "Ranking period",
                        "enum": [
                            "REALTIME",
                            "DAILY",
                            "WEEKLY",
                            "MONTHLY"
                        ],
                        "type": "string",
                        "description": "Time window for the ranking snapshot.",
                        "default": "REALTIME"
                    },
                    "includeSoldOut": {
                        "title": "Include sold-out products",
                        "type": "boolean",
                        "description": "Keep sold-out products in the source ranking.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Strict maximum number of ranked products to save.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```