# Microsoft Store App Intelligence Scraper (`automation-lab/microsoft-store-app-intelligence-scraper`) Actor

🪟 Extract localized Microsoft Store app metadata, pricing, ratings, package details, requirements, images, and publisher links from URLs or ProductIds.

- **URL**: https://apify.com/automation-lab/microsoft-store-app-intelligence-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, E-commerce
- **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

## Microsoft Store App Intelligence Scraper

Extract localized Microsoft Store app metadata from direct product URLs or ProductIds.

Turn Windows Store listings into clean, exportable records for ASO research, catalog governance, competitive intelligence, and recurring app monitoring—without a Microsoft account or private API key.

- 🪟 **App identity:** title, description, ProductId, publisher, categories
- 💵 **Localized commerce:** numeric price, display price, currency, market
- ⭐ **Market signals:** average rating and rating count
- 📦 **Technical catalog:** package family, size, platforms, requirements, capabilities
- 🖼️ **Creative assets:** logo and screenshot URLs
- 🔗 **Governance links:** privacy, support, app website, canonical Store URL
- ⏱️ **Monitoring fields:** release date, update date, version, locale, `fetchedAt`

The Actor uses lightweight HTTP extraction and writes one normalized dataset row per unique app. It is designed for precise product intelligence rather than broad Store search or review crawling.

### What does Microsoft Store App Intelligence Scraper do?

Provide one or more values such as:

- `https://apps.microsoft.com/detail/9wzdncrfj3pz`
- `9WZDNCRFJ3PZ`

The Actor resolves each unique ProductId against the selected market and locale, normalizes Microsoft catalog data, and saves the result to an Apify dataset.

Use the same app IDs on a schedule to detect listing changes over time. Export results as JSON, CSV, Excel, XML, or RSS through Apify.

V1 focuses on validated app-detail extraction. It deliberately does not promise Microsoft Store catalog search or customer review pagination.

### Who is it for?

#### Windows app developers and ASO teams

Compare localized titles, prices, ratings, screenshots, supported languages, and update freshness across a portfolio.

#### Enterprise app-management teams

Refresh package family names, supported platforms, permissions, requirements, publisher information, and support links for internal software catalogs.

#### Competitive-intelligence analysts

Track release cadence, rating momentum, creative assets, and localization across competing Windows apps.

#### Data engineers and agencies

Feed normalized Microsoft Store records into warehouses, spreadsheets, dashboards, or client reporting workflows.

### Why use this Microsoft Store scraper?

- ✅ No browser automation for the normal route
- ✅ No Microsoft login or user-supplied API key
- ✅ Batch input with automatic ProductId deduplication
- ✅ Market and locale controls for localized snapshots
- ✅ Typed numeric ratings, counts, prices, and sizes
- ✅ Source provenance for primary and fallback extraction
- ✅ Conservative retries and concurrency controls
- ✅ Pay per successful app record, not per attempted URL

A failed product is skipped only after the structured catalog endpoint and page-data fallback both fail. The run itself fails if it cannot produce any useful records.

### What Microsoft Store data can I extract?

| Field group | Example fields | Typical use |
|---|---|---|
| Identity | `productId`, `title`, `description` | Catalog matching |
| Publisher | `developer`, `publisher`, `publisherId` | Vendor governance |
| Taxonomy | `categories`, `productType` | Portfolio segmentation |
| Commerce | `price`, `displayPrice`, `currencyCode` | Localized pricing |
| Ratings | `averageRating`, `ratingCount` | ASO monitoring |
| Releases | `releaseDate`, `lastUpdateDate`, `version` | Freshness checks |
| Compatibility | `platforms`, `minimumRequirements` | Device policy |
| Packages | `packageFamilyNames`, size fields | Software inventory |
| Security | `permissions`, `capabilities` | Review workflows |
| Assets | `logoUrl`, `screenshotUrls` | Creative audits |
| Links | privacy, support, website, canonical URL | Compliance checks |
| Provenance | market, locale, source, fetchedAt | Reproducible snapshots |

Optional fields are omitted when Microsoft does not expose them for a given product or market. The Actor does not fill missing values with misleading placeholders.

### How to scrape Microsoft Store app data

1. Open the Actor input page.
2. Paste one or more Microsoft Store product URLs or ProductIds.
3. Select a two-letter market such as `US`, `GB`, or `DE`.
4. Select a locale such as `en-US`, `en-GB`, or `de-DE`.
5. Keep the small default item limit for your first run.
6. Click **Start**.
7. Open the dataset and export the records in your preferred format.

For recurring intelligence, create an Apify schedule and compare each new dataset with the prior run in your automation platform or warehouse.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `appIds` | string array | sample app URL | Direct URLs or ProductIds; required |
| `market` | string | `US` | Two-letter Store market |
| `locale` | string | `en-US` | Language-country locale |
| `maxItems` | integer | `10` | Maximum unique apps, up to 100 |
| `maxConcurrency` | integer | `5` | Simultaneous requests, from 1 to 10 |

Example input:

```json
{
  "appIds": [
    "9WZDNCRFJ3PZ",
    "https://apps.microsoft.com/detail/9nblggh4nns1"
  ],
  "market": "US",
  "locale": "en-US",
  "maxItems": 2,
  "maxConcurrency": 2
}
````

URLs and IDs may be mixed. Duplicate IDs are fetched once. Invalid values are reported in the log and ignored when another valid input remains.

### Output example

```json
{
  "productId": "9WZDNCRFJ3PZ",
  "title": "Company Portal",
  "publisher": "Microsoft Corporation",
  "categories": ["Business"],
  "price": 0,
  "displayPrice": "Free",
  "currencyCode": "USD",
  "averageRating": 3.6,
  "ratingCount": 564,
  "platforms": ["ARM64", "x86", "x64", "ARM"],
  "packageFamilyNames": ["Microsoft.CompanyPortal_8wekyb3d8bbwe"],
  "canonicalUrl": "https://apps.microsoft.com/detail/9wzdncrfj3pz?hl=en-US&gl=US",
  "market": "US",
  "locale": "en-US",
  "source": "storeedge",
  "fetchedAt": "2026-07-15T00:00:00.000Z"
}
```

The live record usually contains additional description, date, language, requirement, capability, image, and support fields.

### How much does it cost to scrape Microsoft Store apps?

This Actor uses pay-per-event pricing:

- **Run start:** $0.005 once per run
- **App detail:** tiered by your Apify plan; current BRONZE reference is $0.00022225 per saved app

A one-app check is about $0.00522 at the BRONZE reference rate. A 100-app refresh is about $0.02723. Higher Apify plans receive lower per-record rates.

The Apify Free plan includes monthly platform credits, so small tests can often fit within existing credits. Check the Actor pricing panel for the exact rate on your plan before a large batch.

You are charged for records saved, not invalid IDs or products that fail both extraction routes.

### Tips for reliable app intelligence

- 🎯 Start with one known ProductId before a portfolio batch.
- 🌍 Use matching market and locale values, such as `DE` with `de-DE`.
- 🧾 Store `productId`, `market`, and `locale` as your comparison key.
- ⏰ Schedule refreshes at a cadence appropriate for release monitoring.
- 📉 Compare rating count deltas as well as average rating changes.
- 🧠 Keep `maxConcurrency` between 2 and 5 for recurring monitors.
- 🔍 Inspect `source`; `page-jsonld` indicates the lower-fidelity fallback was used.

Some package and version fields are not populated by Microsoft for every product. Treat omitted optional values as unavailable, not zero.

### Integrations and automation workflows

#### Google Sheets or Airtable catalog

Schedule the Actor weekly, send dataset rows through Make or Zapier, and upsert by `productId + market + locale`.

#### BigQuery, Snowflake, or PostgreSQL history

Append each run with `fetchedAt`, then calculate update intervals, rating changes, localized price differences, and creative-asset changes.

#### Slack or email release alerts

Compare `lastUpdateDate`, `version`, `displayPrice`, and `ratingCount` with the previous snapshot. Send an alert only when one of those values changes.

#### Enterprise software inventory enrichment

Join ProductIds to package family names, publishers, supported platforms, requirements, privacy URLs, and permissions before application approval.

#### Webhooks

Configure an Apify run-finished webhook to trigger your downstream ETL job as soon as the dataset is ready.

### API usage

Replace `YOUR_TOKEN` with an Apify API token.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/microsoft-store-app-intelligence-scraper').call({
  appIds: ['9WZDNCRFJ3PZ'],
  market: 'US',
  locale: 'en-US',
  maxItems: 1
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/microsoft-store-app-intelligence-scraper').call(run_input={
    'appIds': ['9WZDNCRFJ3PZ'],
    'market': 'US',
    'locale': 'en-US',
    'maxItems': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~microsoft-store-app-intelligence-scraper/runs?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"appIds":["9WZDNCRFJ3PZ"],"market":"US","locale":"en-US","maxItems":1}'
```

### Use with Apify MCP

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/microsoft-store-app-intelligence-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/microsoft-store-app-intelligence-scraper"
    }
  }
}
```

Example prompts:

- “Extract the US Microsoft Store record for ProductId 9WZDNCRFJ3PZ.”
- “Compare price, rating count, and last update date for these five Windows apps.”
- “Return package family names and minimum OS requirements for this app portfolio.”

MCP is useful when an analyst wants current structured catalog data inside an AI-assisted workflow without manually exporting a dataset.

### Data quality and source behavior

The primary source is Microsoft's public Store catalog detail endpoint. It exposes richer package and compatibility data than the visible listing alone.

When that structured route fails, the Actor tries public product-page JSON-LD. Fallback records may contain fewer fields. The `source` field makes this explicit.

Localization can vary by market. An app may be unavailable, priced differently, translated differently, or expose different rating aggregates across markets.

The Actor never fabricates missing fields. Arrays are deduplicated and numeric source values remain numeric.

### Limitations

- Direct app URLs and ProductIds only
- No broad Microsoft Store catalog search in V1
- No customer review pagination in V1
- Maximum 100 unique apps per run
- StoreEdge is undocumented and may change
- Some listings omit version, developer, currency, or package fields
- Market availability can differ from global product existence
- Fallback JSON-LD contains less technical metadata

For a rejected or market-unavailable ID, review the run log and verify that the product opens in the same market.

### Legality of scraping Microsoft Store data

This Actor extracts publicly accessible product metadata. Public availability does not remove your obligations.

Use the data for legitimate purposes, respect applicable Microsoft terms, database rights, copyright, privacy laws, and contractual restrictions, and avoid republishing protected descriptions or images in misleading ways.

Do not use the Actor to bypass access controls. The Actor does not log in, purchase software, download packages, or access private account data.

If your workflow has legal or compliance implications, obtain professional advice appropriate to your jurisdiction and use case.

### Troubleshooting

#### “No Microsoft Store records could be extracted”

Confirm that each value is a ProductId or an `apps.microsoft.com` product URL. Then open the product in the requested market. Some products are region-limited or retired.

#### My localized price or title looks unexpected

Check both `market` and `locale`. Market controls availability and commerce context; locale controls language. Use `GB` with `en-GB`, not `US` with `en-GB`, when you need a UK snapshot.

#### A field is missing

Microsoft does not expose every optional field for every app. Check `source`; fallback `page-jsonld` records are intentionally lower fidelity.

#### A duplicate URL produced one row

This is expected. Inputs are normalized to uppercase ProductIds and deduplicated before fetching.

#### The run is slower than expected

Reduce the batch or keep concurrency near the default. Retries may add time when Microsoft returns temporary errors.

### FAQ

#### Do I need a Microsoft account?

No. The Actor uses public anonymous product-detail surfaces.

#### Can I scrape paid and free apps?

Yes, when the product is publicly available in the selected market. Price fields reflect the response for that market.

#### Can I monitor changes?

Yes. Schedule recurring runs and compare `lastUpdateDate`, `version`, rating fields, price fields, image URLs, and `fetchedAt`.

#### Does it download app packages?

No. This is a metadata and intelligence Actor, not a package downloader.

#### Does it return reviews?

No. Review extraction was not independently validated for V1, so it is excluded rather than over-promised.

#### Can I use more than one locale?

Run the same ProductIds once per market/locale pair. Keep each pair as part of your historical comparison key.

### Related app store scrapers

- [Apple App Store Scraper](https://apify.com/automation-lab/apple-app-store-scraper) — iOS app details, search, ratings, and reviews
- [Google Play Scraper](https://apify.com/automation-lab/google-play-scraper) — Android app intelligence and reviews
- [Google Play Data Safety Scraper](https://apify.com/automation-lab/google-play-data-safety-scraper) — privacy and data-safety declarations
- [Google Play Developer Portfolio Scraper](https://apify.com/automation-lab/google-play-developer-portfolio-scraper) — developer-level Android portfolio monitoring

Use this Actor when the target is the Microsoft Store and Windows catalog metadata. Choose a related Actor only when your source platform or entity scope differs.

### Support

For a reproducible support request, include:

- the ProductId or public product URL
- market and locale
- run ID
- whether the product opens manually in that market
- the field you expected and the value returned

Do not post private credentials or API tokens. The Actor does not need them.

# Actor input Schema

## `appIds` (type: `array`):

Add apps.microsoft.com product URLs or Store ProductIds. Duplicate entries are removed automatically.

## `market` (type: `string`):

Choose the two-letter Store market used for localized availability, currency, and pricing.

## `locale` (type: `string`):

Choose the language-country locale for listing copy, for example en-US, en-GB, or de-DE.

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

Limit how many unique valid app IDs are fetched from this input.

## `maxConcurrency` (type: `integer`):

Control simultaneous Microsoft Store requests. Keep this low for stable recurring monitors.

## Actor input object example

```json
{
  "appIds": [
    "https://apps.microsoft.com/detail/9wzdncrfj3pz"
  ],
  "market": "US",
  "locale": "en-US",
  "maxItems": 1,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `apps` (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 = {
    "appIds": [
        "https://apps.microsoft.com/detail/9wzdncrfj3pz"
    ],
    "market": "US",
    "locale": "en-US",
    "maxItems": 1,
    "maxConcurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/microsoft-store-app-intelligence-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 = {
    "appIds": ["https://apps.microsoft.com/detail/9wzdncrfj3pz"],
    "market": "US",
    "locale": "en-US",
    "maxItems": 1,
    "maxConcurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/microsoft-store-app-intelligence-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 '{
  "appIds": [
    "https://apps.microsoft.com/detail/9wzdncrfj3pz"
  ],
  "market": "US",
  "locale": "en-US",
  "maxItems": 1,
  "maxConcurrency": 3
}' |
apify call automation-lab/microsoft-store-app-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Microsoft Store App Intelligence Scraper",
        "description": "🪟 Extract localized Microsoft Store app metadata, pricing, ratings, package details, requirements, images, and publisher links from URLs or ProductIds.",
        "version": "0.1",
        "x-build-id": "Y3gA0j5kXo8TpKfbe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~microsoft-store-app-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-microsoft-store-app-intelligence-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~microsoft-store-app-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-microsoft-store-app-intelligence-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~microsoft-store-app-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-microsoft-store-app-intelligence-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": [
                    "appIds"
                ],
                "properties": {
                    "appIds": {
                        "title": "🪟 Microsoft Store apps",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add apps.microsoft.com product URLs or Store ProductIds. Duplicate entries are removed automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "market": {
                        "title": "🌍 Market",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Choose the two-letter Store market used for localized availability, currency, and pricing.",
                        "default": "US"
                    },
                    "locale": {
                        "title": "🗣️ Locale",
                        "pattern": "^[A-Za-z]{2,3}[-_][A-Za-z]{2}$",
                        "type": "string",
                        "description": "Choose the language-country locale for listing copy, for example en-US, en-GB, or de-DE.",
                        "default": "en-US"
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limit how many unique valid app IDs are fetched from this input.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "⚙️ Request concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Control simultaneous Microsoft Store requests. Keep this low for stable recurring monitors.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```