# Tokopedia Catalog Monitor (`crawlstone/tokopedia-catalog-monitor`) Actor

Track changes in Tokopedia product prices, stock, availability, and variants across runs. Scrape keyword results, aggregate product details with reviews, and shop details with products and seller reviews—an unofficial Tokopedia scraper for catalog monitoring and marketplace analysis.

- **URL**: https://apify.com/crawlstone/tokopedia-catalog-monitor.md
- **Developed by:** [Crawl Stone](https://apify.com/crawlstone) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 monitor runs

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

## Tokopedia Catalog Monitor

Find Tokopedia products, collect detailed product or shop information, and monitor prices, stock, availability, and variants over time.

> **Unofficial Actor:** Tokopedia Catalog Monitor is an independent tool and is not affiliated with or endorsed by Tokopedia.

### What can this Actor do?

- Search Tokopedia for products using a keyword.
- Get product details, variants, images, and customer reviews.
- Get shop information, products, and seller reviews.
- Monitor up to 10 products for price, stock, availability, and variant changes.
- Continue a monitor later using its saved monitor ID.
- Export results as JSON, CSV, Excel, and other Apify Dataset formats.
- Manage the required Indonesian residential proxy automatically with no proxy setup.

### Quick start

1. Click **Try for free** on the Actor page.
2. Choose what you want to do.
3. Enter a keyword, product URL, shop URL, or monitor ID.
4. Click **Save & Start**.
5. Open the **Output** tab when the run finishes.

For your first run, try discovering products:

```json
{
  "mode": "discover",
  "keyword": "wireless mouse",
  "maxResults": 20
}
````

The Actor saves one result for each product found, up to your selected limit. If Tokopedia returns no matching products, the run still succeeds with an empty Dataset.

### Choose a mode

| Mode | Use it for | Required input | Results |
|---|---|---|---|
| `discover` | Search for products | `keyword` | One result per product found |
| `productDetail` | Inspect one product | `productUrl` | One product with variants and customer reviews |
| `shopDetail` | Inspect one shop | `shopUrl` | One shop with products and seller reviews |
| `monitor` | Track products over time | New monitor: `productUrls`; existing monitor: `monitorId` | One observation per checked product |

The Store form starts with **Discover products** and the sample keyword `laptop`, so its prefilled input is ready to run. Fill in only the fields needed for your chosen mode.

### Input fields

| Field | Used by | What to enter |
|---|---|---|
| `mode` | Every run | `discover`, `productDetail`, `shopDetail`, or `monitor` |
| `keyword` | `discover` | One non-empty Tokopedia search term |
| `maxResults` | `discover` | Optional result limit from 1 to 1,000; default `20` |
| `productUrl` | `productDetail` | One public Tokopedia product URL |
| `shopUrl` | `shopDetail` | One public Tokopedia shop URL |
| `productUrls` | New `monitor` | 1–10 unique public Tokopedia product URLs |
| `monitorId` | Existing `monitor` | The monitor ID returned by an earlier run |
| `maxProducts` | `shopDetail` | Optional product limit from 1 to 1,000; default `20` |
| `maxReviews` | `productDetail`, `shopDetail` | Optional review limit from 1 to 100; default `20` |

Use normal public URLs from `www.tokopedia.com`. Product and shop URLs should not contain query parameters or fragments such as `?source=...` or `#section`.

### Input examples

#### Discover products

```json
{
  "mode": "discover",
  "keyword": "laptop stand",
  "maxResults": 50
}
```

Products remain in the order returned by Tokopedia. If the same product appears more than once in the search results, each occurrence is kept.

#### Get product details

```json
{
  "mode": "productDetail",
  "productUrl": "https://www.tokopedia.com/example-shop/example-product",
  "maxReviews": 20
}
```

The result can include:

- product name, URL, image, price, discount, rating, review count, and sold count;
- description, SKU, categories, images, stock, and availability;
- shop information;
- product variants and options;
- customer reviews, media, helpful counts, and seller replies.

If the product is identifiable but no longer available, the Actor can still return its available public information.

#### Get shop details

```json
{
  "mode": "shopDetail",
  "shopUrl": "https://www.tokopedia.com/example-shop",
  "maxProducts": 20,
  "maxReviews": 20
}
```

The result can include:

- shop name, URL, location, and merchant status;
- products from the shop;
- seller reviews and the products they refer to.

A shop with no returned products or reviews still produces one valid result with empty lists.

### Monitor products over time

Monitoring is useful for price tracking, stock alerts, availability checks, and catalog-change workflows.

#### Create a monitor

Start with 1–10 product URLs:

```json
{
  "mode": "monitor",
  "productUrls": [
    "https://www.tokopedia.com/example-shop/example-product",
    "https://www.tokopedia.com/another-shop/another-product"
  ]
}
```

The first successful run creates a monitor and returns a `monitorId`. Save this ID—you will use it for every later check.

The first observation is a baseline. It records the current product information but does not report changes yet.

#### Continue a monitor

Run the Actor again with the saved ID:

```json
{
  "mode": "monitor",
  "monitorId": "123e4567-e89b-42d3-a456-426614174000"
}
```

Each continuation compares the newest information with the previous successful observation. A result can report changes to:

- product identity;
- availability;
- price;
- stock;
- variants.

The product URL list is fixed when the monitor is created. To track a different set of products, create a new monitor.

#### Schedule regular checks

Use an [Apify Schedule](https://docs.apify.com/platform/schedules) or Task to run the same `monitorId` hourly, daily, or at another interval.

Do not run the same monitor more than once at the same time. Use one schedule or workflow per monitor and avoid overlapping manual runs.

Monitor data is stored in the named `tokpedmon-state` Key-value store. Deleting the corresponding `monitor-<monitorId>` record permanently removes that monitor.

### Understanding the results

Results are saved in the run's default Dataset. The **Output** tab provides separate views for **Monitor**, **Discover**, **Product detail**, and **Shop detail**.

| Mode | Number of results | What each result contains |
|---|---|---|
| `discover` | Zero to `maxResults` | Product information and its shop |
| `productDetail` | One | Product details with variants and customer reviews |
| `shopDetail` | One | Shop details with products and seller reviews |
| `monitor` | One per checked product | Current observation, previous observation when available, and detected changes |

Detailed information remains grouped naturally:

- a product keeps its shop and variants together;
- product details keep customer reviews with the product;
- shop details keep products and seller reviews with the shop;
- monitor results keep previous and current observations together.

This makes the JSON output easy to use from applications while still allowing downloads in other Dataset formats.

Some fields are optional because Tokopedia does not always provide them. Missing information is left out. Confirmed values such as zero stock, zero reviews, or `false` merchant flags are preserved.

### Empty results, partial monitoring, and errors

An empty Dataset can be a valid result when a discovery keyword has no matches. Empty discovery runs are not charged.

Product and shop detail runs are complete-or-fail. If the Actor cannot collect all requested information, it saves one error result when possible, marks the run as failed, and does not charge for the failed result.

Monitoring handles each product separately:

- if some products succeed, their observations are saved together with error results for failed products;
- failed products keep their previous successful monitor information;
- if every product fails, the run is marked as failed, the monitor is left unchanged, and the run is not charged.

An error result includes a readable `message` and may include the affected URL and monitor ID. Source availability can change, so retrying later may resolve temporary failures.

### Use with Apify MCP

You can use Tokopedia Catalog Monitor from MCP-compatible AI clients through Apify's hosted MCP server:

```text
https://mcp.apify.com?tools=crawlstone/tokopedia-catalog-monitor
```

Connect your Apify account using OAuth or an API token, then send the same inputs used in the Store form. For example:

```json
{
  "mode": "discover",
  "keyword": "mechanical keyboard",
  "maxResults": 10
}
```

For monitoring, create the monitor once, keep the returned `monitorId`, and use that ID in later MCP requests. See the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp) for setup instructions.

### Managed proxy

You do **not** need to configure or supply a separate proxy. The Actor automatically uses a managed Indonesian residential proxy for Tokopedia requests. Proxy usage is included in the Actor price, and there are no proxy settings to configure.

### Pricing

You pay only for successfully saved results. The Actor uses these billing events:

- **`discover-product`** — charged for each product saved by `discover`. If no products are found, this event is not charged.
- **`product-detail`** — charged once when a complete `productDetail` result is saved. Included customer reviews do not create an additional charge.
- **`shop-detail`** — charged once when a complete `shopDetail` result is saved, including when the shop has no returned products.
- **`shop-product`** — charged for each product included in a saved `shopDetail` result. It is not charged when the returned product list is empty.
- **`monitor-run`** — charged once when a monitor run saves at least one successful product observation, regardless of how many configured products succeeded.

Error results are free. Failed product or shop detail runs are not charged. A monitor run where every product fails is also free and leaves the previous monitor information unchanged.

Platform and managed proxy usage are included in the Actor price. Check the Actor's **Pricing** tab for current rates and plan pricing. Standard Apify storage costs may still apply if you access or retain data after the run.

### Frequently asked questions

#### Can I monitor more than 10 products?

One monitor supports up to 10 products. Create additional monitors if you need to track more products.

#### Can I add or remove products from an existing monitor?

No. A monitor keeps the product list used when it was created. Create a new monitor for a different list.

#### How often can I check a monitor?

You can use an Apify Schedule at the interval that suits your workflow. Leave enough time for one run to finish before the next starts, because overlapping runs for the same monitor are not supported.

#### Why does the first monitor run show no changes?

The first run creates the baseline used for later comparisons. Changes can only be detected after another successful run.

#### Why is a field missing from a result?

Tokopedia does not always provide every value. Unknown values are omitted rather than guessed. Confirmed zero and false values remain in the result.

#### Why did I receive an error result?

Tokopedia may have returned an unavailable page, blocked a request, changed its response, or temporarily failed. Read the result's `message` for details and try again later when appropriate. Failed one-shot results and all-product monitor failures are not charged.

#### Can I use the Actor from my application?

Yes. Open the **API** tab on the Actor page to copy a request for your preferred language. You can also use webhooks, schedules, integrations, or Apify MCP.

### Privacy and responsible use

The Actor processes public Tokopedia pages and uses your Apify run input and storage. Do not include passwords, tokens, private customer information, or other secrets in the input.

You are responsible for your inputs, stored results, retention settings, compliance with applicable laws and platform terms, and how the collected data is used.

### Support

If you need help, contact support from this Actor's Apify Store page and include:

- the Apify run ID;
- the selected mode;
- the keyword, product URL, shop URL, or monitor ID involved;
- the error message, if available;
- what you expected and what happened.

Never send your Apify API token, proxy credentials, or other secrets.

# Actor input Schema

## `mode` (type: `string`):

Choose one operation. Discover is preselected with a sample keyword for a ready-to-run search.

## `productUrls` (type: `array`):

Used only to create a monitor. Enter 1–10 unique public Tokopedia product URLs. Omit monitorId.

## `monitorId` (type: `string`):

Used only to continue a monitor. Enter the canonical lowercase UUID returned by its creation run and omit productUrls.

## `keyword` (type: `string`):

Required for discover. One trimmed, non-empty Tokopedia search keyword.

## `maxResults` (type: `integer`):

Used only by discover. Results preserve Tokopedia order and duplicate occurrences.

## `productUrl` (type: `string`):

Required for productDetail. A public two-segment Tokopedia product URL without query parameters or a fragment.

## `shopUrl` (type: `string`):

Required for shopDetail. A public one-segment Tokopedia shop URL without query parameters or a fragment.

## `maxProducts` (type: `integer`):

Used only by shopDetail. Limits the products nested in the single shop result.

## `maxReviews` (type: `integer`):

Used by productDetail and shopDetail. Limits nested product reviews or seller reviews respectively.

## Actor input object example

```json
{
  "mode": "discover",
  "monitorId": "123e4567-e89b-12d3-a456-426614174000",
  "keyword": "wireless mouse",
  "maxResults": 20,
  "maxProducts": 20,
  "maxReviews": 20
}
```

# Actor output Schema

## `results` (type: `string`):

Open the default Dataset. Product and shop detail results keep products, variants, and reviews nested. Monitor snapshots are also persisted in the named tokpedmon-state Key-value store, but the Dataset remains the primary run output.

# 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 = {
    "mode": "discover",
    "keyword": "laptop"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlstone/tokopedia-catalog-monitor").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 = {
    "mode": "discover",
    "keyword": "laptop",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlstone/tokopedia-catalog-monitor").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 '{
  "mode": "discover",
  "keyword": "laptop"
}' |
apify call crawlstone/tokopedia-catalog-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tokopedia Catalog Monitor",
        "description": "Track changes in Tokopedia product prices, stock, availability, and variants across runs. Scrape keyword results, aggregate product details with reviews, and shop details with products and seller reviews—an unofficial Tokopedia scraper for catalog monitoring and marketplace analysis.",
        "version": "1.0",
        "x-build-id": "Ej58Qnc3AOicclYfo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlstone~tokopedia-catalog-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlstone-tokopedia-catalog-monitor",
                "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/crawlstone~tokopedia-catalog-monitor/runs": {
            "post": {
                "operationId": "runs-sync-crawlstone-tokopedia-catalog-monitor",
                "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/crawlstone~tokopedia-catalog-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-crawlstone-tokopedia-catalog-monitor",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "monitor",
                            "discover",
                            "productDetail",
                            "shopDetail"
                        ],
                        "type": "string",
                        "description": "Choose one operation. Discover is preselected with a sample keyword for a ready-to-run search."
                    },
                    "productUrls": {
                        "title": "Products to monitor",
                        "minItems": 1,
                        "maxItems": 10,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Used only to create a monitor. Enter 1–10 unique public Tokopedia product URLs. Omit monitorId.",
                        "items": {
                            "type": "string",
                            "pattern": "^https?://www\\.tokopedia\\.com/[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*/?$"
                        }
                    },
                    "monitorId": {
                        "title": "Monitor ID",
                        "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
                        "type": "string",
                        "description": "Used only to continue a monitor. Enter the canonical lowercase UUID returned by its creation run and omit productUrls."
                    },
                    "keyword": {
                        "title": "Search keyword",
                        "minLength": 1,
                        "type": "string",
                        "description": "Required for discover. One trimmed, non-empty Tokopedia search keyword."
                    },
                    "maxResults": {
                        "title": "Maximum discovery results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Used only by discover. Results preserve Tokopedia order and duplicate occurrences.",
                        "default": 20
                    },
                    "productUrl": {
                        "title": "Product URL",
                        "pattern": "^https?://www\\.tokopedia\\.com/[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*/?$",
                        "type": "string",
                        "description": "Required for productDetail. A public two-segment Tokopedia product URL without query parameters or a fragment."
                    },
                    "shopUrl": {
                        "title": "Shop URL",
                        "pattern": "^https?://www\\.tokopedia\\.com/[A-Za-z0-9][A-Za-z0-9._-]*/?$",
                        "type": "string",
                        "description": "Required for shopDetail. A public one-segment Tokopedia shop URL without query parameters or a fragment."
                    },
                    "maxProducts": {
                        "title": "Maximum shop products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Used only by shopDetail. Limits the products nested in the single shop result.",
                        "default": 20
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Used by productDetail and shopDetail. Limits nested product reviews or seller reviews respectively.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
