# TikTok Shop Store Monitor Pro  💾 (`sentry/tiktok-shop-store-monitor-pro`) Actor

Monitor TikTok Shop seller stores and detect catalog changes across runs. Track matched products, price changes, additions, removals, and store-level snapshots for competitive ecommerce intelligence.

- **URL**: https://apify.com/sentry/tiktok-shop-store-monitor-pro.md
- **Developed by:** [Sentry](https://apify.com/sentry) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $25.00 / 1,000 results

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

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

## TikTok Shop Store Monitor Pro

**TikTok Shop Store Monitor Pro** is a production-ready **TikTok Shop scraper** for teams that need continuous **seller monitoring**, **catalog change detection**, and **price intelligence**.

If you are searching for a **TikTok Shop store monitor**, **TikTok Shop competitor tracker**, **TikTok Shop product change tracker**, or **TikTok Shop price tracker**, this actor is built for that exact workflow.

It helps you monitor one or many TikTok Shop stores, detect listing changes between runs, and export clean, structured TikTok Shop ecommerce data you can use in reports, dashboards, and automations.

### Why This TikTok Shop Scraper Is Useful

Most TikTok Shop tools focus on one-off scraping. This actor is built for repeatable monitoring.

You can:

- Track target sellers over time
- Detect newly added products quickly
- Detect products that disappeared from the tracked snapshot window
- Detect price movement and merchandising changes
- Build historical store intelligence for strategy and operations

This makes it ideal for **ecommerce operators**, **agencies**, **competitive intelligence teams**, and **research workflows** that need durable, recurring data.

### High-Value Use Cases

#### 1) TikTok Shop Competitor Monitoring
Monitor competitor stores daily and identify what they add, remove, or repriced.

#### 2) TikTok Shop Product Research
Discover which products persist, which rotate out, and where catalog focus is shifting.

#### 3) TikTok Shop Price Change Intelligence
Track min/max/average price movements across seller catalogs and identify promotional cycles.

#### 4) Seller Assortment Tracking
Measure catalog breadth and product turnover by store for niche-level market mapping.

#### 5) Agency Reporting and Client Deliverables
Create recurring store-change reports with clear product-level proof.

#### 6) Trend Discovery for Merchandising
Spot early shifts in product mix and pricing strategy before they become obvious.

### What Data You Get

This actor outputs structured rows with fields designed for analytics.

#### Core Product Fields

- `product_id`
- `product_name`
- `product_url`
- `seller`
- `brand_name`
- `min_price`, `max_price`, `avg_price`
- `currency_symbol`
- `product_rating`
- `review_count`
- `rank_global`
- `source_url`
- `scraped_at`

#### Store Context Fields

- `monitor_store_name`
- `monitor_store_key`
- `monitor_store_input`
- `monitor_query`

#### Change Tracking Fields

- `row_type`
- `change_type`
- `previous_min_price`, `previous_max_price`, `previous_avg_price`
- `current_min_price`, `current_max_price`, `current_avg_price`
- `changes_added`, `changes_removed`, `changes_price_changed`

### Output Row Types (Important)

This actor emits multiple row types so you can analyze both current state and changes.

- `store_product`
  Current matched listings captured in this run.

- `store_change`
  Snapshot delta rows:
  - `added`
  - `removed`
  - `price_changed`

- `store_summary`
  Store-level rollup for operational monitoring.

### Inputs (Practical Configuration)

#### Required

- `stores`
  List of store names and/or TikTok Shop store URLs.

#### Optional Discovery Control

- `queries`
  Optional query hints. If omitted, store names are used.

#### Scope and Coverage

- `searchRegion`
- `maxPagesPerStore`
- `maxProductsPerStore`
- `maxQueriesPerStore`

#### Change Detection and State

- `enableSnapshotDiff`
- `emitChangeRows`
- `emitStoreSummary`
- `maxChangeRowsPerStore`
- `snapshotKeyPrefix`
- `stateStoreName`

#### Reliability and Stability

- `requestTimeoutSec`
- `maxFetchRetries`
- `queryRetryAttempts`
- `allowDirectRescueOnSoftBlock`
- `enableBrowserFallback`
- `browserFallbackWaitMs`
- `failOnZeroAfterRetries`

#### Proxy

- `proxyConfiguration`
  Use Apify proxy selector (residential/datacenter/custom) according to your reliability needs.

### Recommended Settings (Most Users)

For stable recurring TikTok Shop monitoring:

- `maxPagesPerStore`: `3`
- `maxProductsPerStore`: `200`
- `maxQueriesPerStore`: `2`
- `enableSnapshotDiff`: `true`
- `emitChangeRows`: `true`
- `emitStoreSummary`: `true`
- `compactNullFields`: `true`
- `maxFetchRetries`: `3`
- `queryRetryAttempts`: `3`

If you want stronger removal confidence, increase `maxPagesPerStore`.

### Example Input

```json
{
  "stores": [
    "Sweet Furniture",
    "https://www.tiktok.com/shop/store/dowinx"
  ],
  "searchRegion": "US",
  "maxPagesPerStore": 3,
  "maxProductsPerStore": 200,
  "maxQueriesPerStore": 2,
  "enableSnapshotDiff": true,
  "emitStoreSummary": true,
  "emitChangeRows": true,
  "stateStoreName": "tiktok-shop-store-monitor-state"
}
````

### Who Should Use This

- TikTok Shop brands and operators
- Ecommerce analysts
- Product researchers
- Competitive intelligence teams
- Marketing agencies
- Automation and BI teams

### FAQ

#### Why do I see both `store_product` and `store_change` rows?

`store_product` is current-run state. `store_change` is the diff versus previous snapshot.

#### Does `removed` always mean permanently deleted?

Not always. It means missing from current tracked snapshot versus prior run. Increase coverage depth for stricter confidence.

#### Can this run on a schedule for daily monitoring?

Yes. This actor is designed for recurring runs and longitudinal analysis.

#### Is this useful for TikTok Shop competitor research?

Yes. That is one of the primary workflows.

### SEO Search Intent Coverage

This actor is optimized for high-intent search terms including:

- TikTok Shop scraper
- TikTok Shop store scraper
- TikTok Shop store monitor
- TikTok Shop seller monitor
- TikTok Shop competitor tracker
- TikTok Shop product tracker
- TikTok Shop product change tracker
- TikTok Shop catalog monitor
- TikTok Shop catalog tracker
- TikTok Shop price tracker
- TikTok Shop price change monitor
- TikTok Shop competitor analysis tool
- TikTok Shop seller intelligence scraper
- TikTok Shop ecommerce data scraper
- TikTok Shop market research scraper
- TikTok Shop monitoring API alternative

If your objective is repeatable, actionable **TikTok Shop seller intelligence**, this actor gives you the data model needed for operations, reporting, and strategic decision-making.

# Actor input Schema

## `stores` (type: `array`):

TikTok Shop store names or store URLs. The actor tracks matching products and detects catalog changes per store.

## `queries` (type: `array`):

Optional search terms used for discovery. If empty, each store name is used as its own query hint.

## `searchRegion` (type: `string`):

Region parameter sent to TikTok Shop search pages (for example: US, GB).

## `maxPagesPerStore` (type: `integer`):

Maximum number of search-result pages scanned per store query path.

## `maxProductsPerStore` (type: `integer`):

Maximum number of unique matched products emitted per store in one run.

## `maxQueriesPerStore` (type: `integer`):

How many query hints are used per store during a run.

## `includeRawProduct` (type: `boolean`):

Include the full raw product object in each product row.

## `compactNullFields` (type: `boolean`):

If true, null/undefined fields are omitted from output rows.

## `enableSnapshotDiff` (type: `boolean`):

Store per-store snapshots in key-value storage and detect additions/removals/price changes against the previous run.

## `emitStoreSummary` (type: `boolean`):

Push one store\_summary row per monitored store.

## `emitChangeRows` (type: `boolean`):

Push store\_change rows for added/removed/price\_changed products.

## `maxChangeRowsPerStore` (type: `integer`):

Safety cap for emitted change rows per change type per store.

## `snapshotKeyPrefix` (type: `string`):

KVS key prefix used to store per-store snapshots.

## `stateStoreName` (type: `string`):

Named key-value store used to persist snapshots across runs for change detection.

## `requestTimeoutSec` (type: `integer`):

HTTP request timeout for each page request.

## `maxFetchRetries` (type: `integer`):

How many HTTP fetch attempts to try per page before giving up.

## `queryRetryAttempts` (type: `integer`):

How many full retries to run per store query when blocked/failure signals produce zero matched products.

## `allowDirectRescueOnSoftBlock` (type: `boolean`):

When proxy pages are soft-blocked, try one direct (no-proxy) fetch rescue before giving up that page.

## `enableBrowserFallback` (type: `boolean`):

If blocked/challenged and extraction is empty, try a lightweight Playwright fallback.

## `browserFallbackWaitMs` (type: `integer`):

How long browser fallback waits after page load before reading HTML.

## `failOnZeroAfterRetries` (type: `boolean`):

If true, fail run when all monitored stores return zero matched products after retries under blocked conditions.

## `proxyConfiguration` (type: `object`):

Choose proxy type and settings (Apify Proxy residential/datacenter or custom proxies).

## Actor input object example

```json
{
  "stores": [
    "Sweet Furniture",
    "https://www.tiktok.com/shop/store/dowinx"
  ],
  "searchRegion": "US",
  "maxPagesPerStore": 3,
  "maxProductsPerStore": 200,
  "maxQueriesPerStore": 2,
  "includeRawProduct": true,
  "compactNullFields": true,
  "enableSnapshotDiff": true,
  "emitStoreSummary": true,
  "emitChangeRows": true,
  "maxChangeRowsPerStore": 250,
  "snapshotKeyPrefix": "STORE_MONITOR_SNAPSHOT",
  "stateStoreName": "tiktok-shop-store-monitor-state",
  "requestTimeoutSec": 30,
  "maxFetchRetries": 3,
  "queryRetryAttempts": 3,
  "allowDirectRescueOnSoftBlock": true,
  "enableBrowserFallback": false,
  "browserFallbackWaitMs": 8000,
  "failOnZeroAfterRetries": false
}
```

# Actor output Schema

## `results` (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 = {
    "stores": [
        "Sweet Furniture",
        "https://www.tiktok.com/shop/store/dowinx"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sentry/tiktok-shop-store-monitor-pro").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 = { "stores": [
        "Sweet Furniture",
        "https://www.tiktok.com/shop/store/dowinx",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sentry/tiktok-shop-store-monitor-pro").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 '{
  "stores": [
    "Sweet Furniture",
    "https://www.tiktok.com/shop/store/dowinx"
  ]
}' |
apify call sentry/tiktok-shop-store-monitor-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sentry/tiktok-shop-store-monitor-pro",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Store Monitor Pro  💾",
        "description": "Monitor TikTok Shop seller stores and detect catalog changes across runs. Track matched products, price changes, additions, removals, and store-level snapshots for competitive ecommerce intelligence.",
        "version": "0.0",
        "x-build-id": "4bQFRQQBR1wcLd0gD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sentry~tiktok-shop-store-monitor-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sentry-tiktok-shop-store-monitor-pro",
                "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/sentry~tiktok-shop-store-monitor-pro/runs": {
            "post": {
                "operationId": "runs-sync-sentry-tiktok-shop-store-monitor-pro",
                "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/sentry~tiktok-shop-store-monitor-pro/run-sync": {
            "post": {
                "operationId": "run-sync-sentry-tiktok-shop-store-monitor-pro",
                "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": [
                    "stores"
                ],
                "properties": {
                    "stores": {
                        "title": "Stores To Monitor",
                        "type": "array",
                        "description": "TikTok Shop store names or store URLs. The actor tracks matching products and detects catalog changes per store.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Optional Search Queries",
                        "type": "array",
                        "description": "Optional search terms used for discovery. If empty, each store name is used as its own query hint.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchRegion": {
                        "title": "Search Region",
                        "type": "string",
                        "description": "Region parameter sent to TikTok Shop search pages (for example: US, GB).",
                        "default": "US"
                    },
                    "maxPagesPerStore": {
                        "title": "Max Pages Per Store",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of search-result pages scanned per store query path.",
                        "default": 3
                    },
                    "maxProductsPerStore": {
                        "title": "Max Products Per Store",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of unique matched products emitted per store in one run.",
                        "default": 200
                    },
                    "maxQueriesPerStore": {
                        "title": "Max Queries Per Store",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many query hints are used per store during a run.",
                        "default": 2
                    },
                    "includeRawProduct": {
                        "title": "Include Raw Product Payload",
                        "type": "boolean",
                        "description": "Include the full raw product object in each product row.",
                        "default": true
                    },
                    "compactNullFields": {
                        "title": "Compact Null Fields",
                        "type": "boolean",
                        "description": "If true, null/undefined fields are omitted from output rows.",
                        "default": true
                    },
                    "enableSnapshotDiff": {
                        "title": "Enable Snapshot Diff",
                        "type": "boolean",
                        "description": "Store per-store snapshots in key-value storage and detect additions/removals/price changes against the previous run.",
                        "default": true
                    },
                    "emitStoreSummary": {
                        "title": "Emit Store Summary Rows",
                        "type": "boolean",
                        "description": "Push one store_summary row per monitored store.",
                        "default": true
                    },
                    "emitChangeRows": {
                        "title": "Emit Change Rows",
                        "type": "boolean",
                        "description": "Push store_change rows for added/removed/price_changed products.",
                        "default": true
                    },
                    "maxChangeRowsPerStore": {
                        "title": "Max Change Rows Per Store",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Safety cap for emitted change rows per change type per store.",
                        "default": 250
                    },
                    "snapshotKeyPrefix": {
                        "title": "Snapshot Key Prefix",
                        "type": "string",
                        "description": "KVS key prefix used to store per-store snapshots.",
                        "default": "STORE_MONITOR_SNAPSHOT"
                    },
                    "stateStoreName": {
                        "title": "State Store Name",
                        "type": "string",
                        "description": "Named key-value store used to persist snapshots across runs for change detection.",
                        "default": "tiktok-shop-store-monitor-state"
                    },
                    "requestTimeoutSec": {
                        "title": "Request Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP request timeout for each page request.",
                        "default": 30
                    },
                    "maxFetchRetries": {
                        "title": "Max Fetch Retries",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many HTTP fetch attempts to try per page before giving up.",
                        "default": 3
                    },
                    "queryRetryAttempts": {
                        "title": "Full Query Retry Attempts",
                        "minimum": 2,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many full retries to run per store query when blocked/failure signals produce zero matched products.",
                        "default": 3
                    },
                    "allowDirectRescueOnSoftBlock": {
                        "title": "Allow Direct Rescue On Soft-Block",
                        "type": "boolean",
                        "description": "When proxy pages are soft-blocked, try one direct (no-proxy) fetch rescue before giving up that page.",
                        "default": true
                    },
                    "enableBrowserFallback": {
                        "title": "Enable Browser Fallback On Block",
                        "type": "boolean",
                        "description": "If blocked/challenged and extraction is empty, try a lightweight Playwright fallback.",
                        "default": false
                    },
                    "browserFallbackWaitMs": {
                        "title": "Browser Fallback Wait (ms)",
                        "minimum": 1000,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "How long browser fallback waits after page load before reading HTML.",
                        "default": 8000
                    },
                    "failOnZeroAfterRetries": {
                        "title": "Fail Run If Zero After Retries",
                        "type": "boolean",
                        "description": "If true, fail run when all monitored stores return zero matched products after retries under blocked conditions.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Choose proxy type and settings (Apify Proxy residential/datacenter or custom proxies)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```