# Reviewbot Microsoft Api Review Scraper (`reviewbot/microsoft-api-review-scraper`) Actor

Fetch reviews from the Microsoft Store using the official API. Retrieve fast, reliable review data with ratings, text, and metadata. Ideal for Windows app developers, enterprise monitoring, and large-scale review analytics.

- **URL**: https://apify.com/reviewbot/microsoft-api-review-scraper.md
- **Developed by:** [reviewbot](https://apify.com/reviewbot) (community)
- **Categories:** Automation, Integrations, MCP servers
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.05 / 1,000 paid store reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Microsoft Store Review Scraper

Extract reviews from Windows apps on Microsoft Store using the official API.

### What This Actor Does

The Microsoft Store Review Scraper revolutionizes Windows app review extraction by leveraging Microsoft's official API endpoints. This breakthrough approach provides unparalleled performance and unique metadata unavailable through traditional scraping methods, making it the most reliable solution for Microsoft Store review data.

**Perfect for:**

* 💻 **Windows Developers** - Monitor desktop and universal Windows app feedback with unprecedented speed and reliability
* 🏢 **Enterprise Software Teams** - Analyze user feedback for business applications, productivity tools, and enterprise solutions
* 🎮 **Game Developers** - Track user reviews for Xbox and Windows gaming applications with detailed device and OS insights
* 🔧 **System Administrators** - Monitor user sentiment for enterprise deployment tools, utilities, and productivity applications
* 📊 **Business Intelligence** - Access unique Windows-specific metadata like OS versions, device families, and helpfulness metrics

**Why Use This Actor:**

* **Revolutionary Performance**: 100x faster than traditional scraping - extract 250 reviews in just 10 seconds
* **Official API Access**: Direct access to Microsoft's review database with 99.9% reliability and no anti-bot detection
* **Unique Metadata**: Access Windows-specific data like OS versions, device families, and helpfulness scores unavailable elsewhere
* **Enterprise-Grade**: Built for production use with linear scaling and predictable performance characteristics
* **Zero Authentication**: No API keys or complex setup required - ready to use immediately

### Quick Start

#### Using Apify Console

1. Go to [Apify Console](https://console.apify.com/actors/xuW1LbE80G87ujqSA)
2. Configure input parameters and run

#### Using Apify CLI

```bash
npm install -g apify-cli
apify run xuW1LbE80G87ujqSA --input='{"appId": "9nksqgp7f2nh", "limit": 100}'
````

### Key Advantages

🚀 **100x Performance Improvement** over traditional scraping

- **Official API**: Direct access to Microsoft's review database
- **Speed**: 250 reviews in ~10 seconds (vs. 6+ seconds for 0 reviews with DOM scraping)
- **Reliability**: 99.9% success rate
- **Rich Metadata**: OS version, helpfulness, device family, etc.

### Input Parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `appId` | string | ✓ | Microsoft Store app ID (e.g., "9nksqgp7f2nh") |
| `limit` | number | | Maximum reviews to extract (default: 100) |
| `market` | string | | Market code: "US", "GB", "DE", "FR", etc. |
| `locale` | string | | Locale code: "en-US", "de-DE", "fr-FR", etc. |
| `ratings` | array | | Filter by ratings: `[4,5]` for 4-5 star reviews |
| `startDate` | string | | Extract reviews after this date: "2024-01-01" |
| `endDate` | string | | Extract reviews before this date: "2024-12-31" |

### Usage Examples

#### Basic Usage

```json
{
  "appId": "9nksqgp7f2nh",
  "limit": 100
}
```

#### Advanced Configuration

```json
{
  "appId": "9wzdncrfj3tj",
  "limit": 250,
  "market": "US",
  "locale": "en-US",
  "ratings": [4, 5],
  "startDate": "2024-01-01"
}
```

### Using Apify SDK

#### JavaScript Example

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

const client = new ApifyApi({
  token: 'YOUR_APIFY_TOKEN',
});

async function getWindowsReviews() {
  const run = await client.actor('xuW1LbE80G87ujqSA').call({
    appId: '9nksqgp7f2nh', // WhatsApp
    limit: 250,
    market: 'US',
    locale: 'en-US'
  });

  const { items } = await client.dataset(run.defaultDatasetId).listItems();
  console.log(`Downloaded ${items.length} Windows app reviews`);
  return items;
}

getWindowsReviews();
```

#### Python Example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('xuW1LbE80G87ujqSA').call(run_input={
    'appId': '9ncbcszsjrsb',  # Spotify
    'limit': 100,
    'market': 'US',
    'ratings': [4, 5]
})

items = client.dataset(run['defaultDatasetId']).list_items().items
for review in items:
    print(f"{review['rating']}⭐ OS: {review.get('osVersion', 'N/A')} - {review['text'][:100]}...")
```

### cURL Examples

#### Run Actor

```bash
curl -X POST 'https://api.apify.com/v2/acts/xuW1LbE80G87ujqSA/runs' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "appId": "9wzdncrfj3tj",
    "limit": 100,
    "market": "US"
  }'
```

#### Get Results

```bash
curl 'https://api.apify.com/v2/datasets/DATASET_ID/items?format=json' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN'
```

### Output Format

Rich metadata unique to Microsoft Store:

```json
[
  {
    "reviewId": "microsoft-review-123",
    "author": "WindowsUser2024", 
    "rating": 5,
    "title": "Excellent Windows app!",
    "text": "Works perfectly on Windows 11. Great performance.",
    "reviewedAt": "2024-01-15T10:30:00.000Z",
    "store": "microsoft",
    "osVersion": "10.0.26100.6899",
    "helpfulPositive": 15,
    "helpfulNegative": 2,
    "deviceFamily": "Windows.Desktop",
    "isRevised": false,
    "source": "microsoft-api"
  }
]
```

### 💳 Pricing & Cost Control

This Actor uses **Pay-Per-Event (PPE)** pricing, so you only pay for the reviews you actually receive.

#### How Pricing Works

- ✅ **First 10 reviews are FREE** on every run
- 💵 **$0.00005 per additional review**
- 📦 Charges are based on the **number of reviews returned**, not runtime

**Example:**

| Reviews Returned | Free Reviews | Paid Reviews | Total Cost |
|------------------|--------------|--------------|------------|
| 10               | 10           | 0            | $0.00      |
| 50               | 10           | 40           | $0.002     |
| 100              | 10           | 90           | $0.0045    |
| 1,000            | 10           | 990          | $0.0495    |

### Finding Microsoft Store App IDs

#### Method 1: Microsoft Store URL

From `https://apps.microsoft.com/store/detail/whatsapp/9NKSQGP7F2NH`, the ID is `9NKSQGP7F2NH`

#### Method 2: Using Web Inspector

1. Open Microsoft Store in browser
2. Right-click → Inspect
3. Look for `data-appid` or search for app ID pattern

#### Method 3: PowerShell (Windows)

```powershell
Get-AppxPackage | Where-Object {$_.Name -like "*whatsapp*"} | Select-Object Name, PackageFullName
```

### Popular Apps for Testing

| App | Store ID | Category |
|-----|----------|----------|
| WhatsApp | `9nksqgp7f2nh` | Social |
| Netflix | `9wzdncrfj3tj` | Entertainment |
| Spotify | `9ncbcszsjrsb` | Music |
| Instagram | `9nblggh5l9xt` | Social |
| Disney+ | `9nxqxxlfst89` | Entertainment |
| TikTok | `9nh2gp4jn9rb` | Entertainment |
| Zoom | `9wzdncrfj4mv` | Business |
| Adobe Photoshop | `9wzdncrfjc5h` | Creative |

### Regional Markets

#### Supported Markets

- **Americas**: US, CA, MX, BR
- **Europe**: GB, DE, FR, ES, IT, NL, SE, NO, DK
- **Asia-Pacific**: AU, JP, KR, SG, HK, IN, CN
- **Others**: Most global Microsoft Store markets

#### Example: German Market

```json
{
  "appId": "9nksqgp7f2nh",
  "market": "DE",
  "locale": "de-DE",
  "limit": 100
}
```

### Performance Benchmarks

| Reviews | API Calls | Time | Throughput |
|---------|-----------|------|------------|
| 20 | 1 | ~0.6s | 33 reviews/sec |
| 50 | 3 | ~2.3s | 22 reviews/sec |
| 100 | 5 | ~4.5s | 22 reviews/sec |
| 250 | 13 | ~9.6s | 26 reviews/sec |

**Linear scaling**: ~700ms per additional 20 reviews

### Error Handling

Common error responses:

```json
{
  "error": {
    "type": "APP_NOT_FOUND",
    "message": "App not found in Microsoft Store",
    "appId": "invalid-id"
  }
}
```

```json
{
  "error": {
    "type": "MARKET_NOT_SUPPORTED",
    "message": "App not available in specified market",
    "market": "XX"
  }
}
```

### API Details

#### Official Endpoint

```
GET https://apps.microsoft.com/api/products/getReviews/{appId}
```

#### Query Parameters

- `orderBy=5`: Sort by newest first
- `pgNo={page}`: Page number (1-based)
- `noItems=20`: Items per page (max 20)
- `gl={market}`: Market code
- `hl={locale}`: Locale code

#### No Authentication Required

- No API key needed
- No rate limiting observed
- Simple HTTP GET requests

### Support

- [Apify Documentation](https://docs.apify.com)
- [Microsoft Store Developer Center](https://developer.microsoft.com/en-us/microsoft-store/)
- [Community Forum](https://community.apify.com)

# Actor input Schema

## `appId` (type: `string`):

Microsoft Store app name or search term (e.g., 9nksqgp7f2nh (WhatsApp))

## `limit` (type: `integer`):

Maximum number of reviews to scrape (default: 100, max: 500)

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

Microsoft Store market code. Use 'auto' for intelligent market detection.

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

Locale code for reviews (auto-detects based on market if not specified)

## `startDate` (type: `string`):

Filter reviews from this date (ISO format: YYYY-MM-DD)

## `endDate` (type: `string`):

Filter reviews until this date (ISO format: YYYY-MM-DD)

## `ratings` (type: `array`):

Include only these star ratings (default: all ratings)

## `webhookUrl` (type: `string`):

Your webhook endpoint to receive review data in real-time

## `webhookApiKey` (type: `string`):

API key for webhook authentication (sent in Authorization header)

## Actor input object example

```json
{
  "appId": "9nksqgp7f2nh",
  "limit": 100,
  "market": "auto",
  "locale": "auto",
  "startDate": "2024-01-01",
  "endDate": "2024-12-31",
  "ratings": [
    4,
    5
  ],
  "webhookUrl": "https://your-api.com/webhooks/reviews"
}
```

# Actor output Schema

## `source` (type: `string`):

Source platform identifier

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

Target app store platform

## `appId` (type: `string`):

Microsoft Store application identifier

## `runId` (type: `string`):

Unique identifier for this scraping run

## `actorId` (type: `string`):

Unique identifier for the Apify actor

## `appName` (type: `string`):

Name of the application

## `developer` (type: `string`):

App developer/publisher name

## `appRating` (type: `string`):

Overall app rating from the Microsoft Store

## `appUrl` (type: `string`):

Direct URL to the app in the Microsoft Store

## `reviews` (type: `string`):

Array of scraped user reviews

## `metadata` (type: `string`):

Additional information about the scraping process and results

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewbot/microsoft-api-review-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("reviewbot/microsoft-api-review-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 '{}' |
apify call reviewbot/microsoft-api-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reviewbot Microsoft Api Review Scraper",
        "description": "Fetch reviews from the Microsoft Store using the official API. Retrieve fast, reliable review data with ratings, text, and metadata. Ideal for Windows app developers, enterprise monitoring, and large-scale review analytics.",
        "version": "1.0",
        "x-build-id": "OiZ8mm3dP86vmXWBb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewbot~microsoft-api-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewbot-microsoft-api-review-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/reviewbot~microsoft-api-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewbot-microsoft-api-review-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/reviewbot~microsoft-api-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewbot-microsoft-api-review-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": [
                    "appId"
                ],
                "properties": {
                    "appId": {
                        "title": "App Name/ID",
                        "type": "string",
                        "description": "Microsoft Store app name or search term (e.g., 9nksqgp7f2nh (WhatsApp))",
                        "default": "9nksqgp7f2nh"
                    },
                    "limit": {
                        "title": "Review Limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape (default: 100, max: 500)",
                        "default": 100
                    },
                    "market": {
                        "title": "Market",
                        "enum": [
                            "auto",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "JP",
                            "KR",
                            "SG",
                            "HK",
                            "BR",
                            "MX",
                            "IN",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "PL",
                            "CZ",
                            "RU",
                            "TR",
                            "IL",
                            "AE",
                            "SA",
                            "ZA",
                            "EG"
                        ],
                        "type": "string",
                        "description": "Microsoft Store market code. Use 'auto' for intelligent market detection.",
                        "default": "auto"
                    },
                    "locale": {
                        "title": "Locale",
                        "enum": [
                            "auto",
                            "en-US",
                            "en-GB",
                            "en-CA",
                            "en-AU",
                            "de-DE",
                            "fr-FR",
                            "es-ES",
                            "it-IT",
                            "nl-NL",
                            "ja-JP",
                            "ko-KR",
                            "zh-SG",
                            "zh-HK",
                            "pt-BR",
                            "es-MX",
                            "hi-IN",
                            "sv-SE",
                            "nb-NO",
                            "da-DK",
                            "fi-FI",
                            "pl-PL",
                            "cs-CZ",
                            "ru-RU",
                            "tr-TR",
                            "he-IL",
                            "ar-AE",
                            "ar-SA",
                            "en-ZA",
                            "ar-EG"
                        ],
                        "type": "string",
                        "description": "Locale code for reviews (auto-detects based on market if not specified)",
                        "default": "auto"
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Filter reviews from this date (ISO format: YYYY-MM-DD)"
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Filter reviews until this date (ISO format: YYYY-MM-DD)"
                    },
                    "ratings": {
                        "title": "Rating Filter",
                        "type": "array",
                        "description": "Include only these star ratings (default: all ratings)",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 5
                        },
                        "default": [
                            1,
                            2,
                            3,
                            4,
                            5
                        ]
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (Optional)",
                        "type": "string",
                        "description": "Your webhook endpoint to receive review data in real-time"
                    },
                    "webhookApiKey": {
                        "title": "Webhook API Key (Optional)",
                        "type": "string",
                        "description": "API key for webhook authentication (sent in Authorization header)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```