# Tokopedia Scraper — Indonesia #1 Marketplace Product Search (`haketa/tokopedia-scraper`) Actor

Scrape Tokopedia product search results by keyword or URL. Extract product name, price, rating, review count, discount, shop info, category breadcrumb, and images. Pure HTTP GraphQL API — fast, low-cost, no browser overhead. Perfect for market research, competitor monitoring, and lead generation.

- **URL**: https://apify.com/haketa/tokopedia-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 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.
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.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

## Tokopedia Scraper — Indonesia #1 Marketplace Product Search

Extract product search results from Tokopedia, Indonesia's largest e-commerce platform with over 100 million monthly active users. This scraper pulls product listings — name, price, rating, review count, discount, shop details, category breadcrumb, and images — directly from Tokopedia's data source using a fast, lightweight HTTP-only approach with no browser overhead.

### Why This Tokopedia Scraper?

Most Tokopedia scrapers rely on heavy headless browsers (Puppeteer/Playwright) to render JavaScript pages, driving up cost and runtime. This scraper communicates directly with the public product data API, delivering results **5-10× faster** and at a **fraction of the cost** of browser-based alternatives. A single search for 1,000 products typically completes in under 30 seconds and costs less than $0.05 in platform usage.

#### Key Advantages

- **Pure HTTP — no browser**: Communicates directly with the GraphQL data source. No rendering, no JavaScript, no captchas.
- **Fast & cheap**: ~1–2 seconds per page of 60 results. Browser scrapers need 8–15 seconds per page.
- **Anti-bot bypass built-in**: Uses mobile-device header emulation to pass through bot detection without residential proxies.
- **Deduplication**: Never outputs duplicate products — tracks seen IDs across all pages.
- **Multi-keyword**: Run multiple searches in a single run. Great for category-wide market research.
- **Flexible sorting**: Relevance, newest, top sales, price low-to-high, price high-to-low, highest rating.

### What Data Does It Extract?

Every product result includes the following fields:

| Field | Description |
|---|---|
| `id` | Tokopedia product ID |
| `name` | Product title |
| `url` | Product page URL on tokopedia.com |
| `price` | Display price (e.g. "Rp370.000") |
| `priceRaw` | Numeric price in IDR (e.g. 370000) |
| `originalPrice` | Pre-discount price if discounted |
| `originalPriceRaw` | Numeric pre-discount price |
| `discountPercentage` | Discount rate (0–100) |
| `priceRange` | Price range string if multi-variant |
| `rating` | Numeric rating score |
| `ratingAverage` | Average star rating |
| `countReview` | Number of reviews |
| `wishlist` | Whether on wishlist |
| `imageUrl` | Main product image |
| `videoUrl` | Product video if available |
| `categoryId` | Tokopedia category ID |
| `categoryName` | Category name |
| `categoryBreadcrumb` | Full category path |
| `shopId` | Seller shop ID |
| `shopName` | Seller shop name |
| `shopUrl` | Seller shop URL |
| `shopCity` | Seller location city |
| `shopIsOfficial` | Whether an official brand store |
| `shopIsPowerBadge` | Power seller badge status |
| `searchKeyword` | The keyword used for this result |
| `searchUrl` | The search URL that produced this result |
| `scrapedAt` | ISO timestamp of extraction |

### Use Cases

#### E-commerce Market Research
Track product availability, pricing trends, and category composition across Indonesia's largest marketplace. Run weekly searches for your product category to monitor new entrants and price movements.

#### Competitive Intelligence
Search for competitor brand names and products. See how they price, how many reviews they have, whether they run discounts, and which shops carry their products.

#### Lead Generation for Sellers & Brands
Find shops selling in your category. Extract seller names, locations, and shop URLs. Identify official stores and power sellers for partnership or distribution opportunities.

#### Dropshipping & Product Sourcing
Discover trending products and bestsellers. Sort by top sales or newest to find winning products for your own store. Use category breadcrumbs to explore related niches.

#### Price Monitoring
Track specific products or categories over time. Combine with scheduled runs (Apify Schedules) to build price history datasets. Set `maxItemsPerSearch` to 500+ for comprehensive coverage.

#### Academic & Data Science Research
Study Indonesia's e-commerce ecosystem — the 4th largest globally by population. Extract structured data for economic analysis, consumer behavior studies, or marketplace dynamics research.

### Input Parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `searchKeywords` | string array | No* | Product keywords to search. Each runs independently. Example: `["iphone 15", "sepatu nike"]` |
| `startUrls` | string array | No* | Direct Tokopedia search or category URLs. Example: `["https://www.tokopedia.com/search?q=laptop"]` |
| `maxItemsPerSearch` | integer | No | Max products per keyword/URL. Default 100. Set 0 for unlimited. |
| `maxTotalItems` | integer | No | Global cap across all searches. Default 0 (unlimited). |
| `rowsPerPage` | integer | No | Results per API request (1–60). Default 60 for efficiency. |
| `sortOrder` | select | No | Sort order: 23=Relevance, 5=Newest, 8=Top Sales, 11=Price Low-High, 10=Price High-Low, 9=Rating |
| `proxyConfiguration` | proxy | No | Proxy settings. Datacenter proxy recommended for scale. |

\* At least one of `searchKeywords` or `startUrls` is required.

#### Sort Order Reference

| Value | Meaning |
|---|---|
| `23` | Relevance (default) |
| `5` | Newest first |
| `8` | Top sales |
| `11` | Price: Low → High |
| `10` | Price: High → Low |
| `9` | Highest rating |

### Output Format

Results are stored in the Apify Dataset as JSON objects. Each object represents one unique product from the search results.

```json
{
    "id": "13252523998",
    "name": "Lifesafer Anti Heat Iphone 15 Promax Aluminium Case Aromatherapy - Silver",
    "url": "https://www.tokopedia.com/wijayakusumaolshop/lifesafer-anti-heat-iphone-15-promax-aluminium-case-aromatherapy-silver",
    "price": "Rp370.000",
    "priceRaw": 370000,
    "originalPrice": "",
    "originalPriceRaw": null,
    "discountPercentage": 0,
    "priceRange": "",
    "rating": 5,
    "ratingAverage": 5.0,
    "countReview": 12,
    "wishlist": false,
    "imageUrl": "https://images.tokopedia.net/img/cache/700-square/VqbWKr/2024/12/...jpg",
    "videoUrl": "",
    "categoryId": 65,
    "categoryName": "Soft Case Handphone",
    "categoryBreadcrumb": "handphone-tablet/aksesoris-handphone/soft-case-handphone",
    "shopId": "11279607",
    "shopName": "wijayakusumaolshop",
    "shopUrl": "https://www.tokopedia.com/wijayakusumaolshop",
    "shopCity": "Jakarta Barat",
    "shopIsOfficial": false,
    "shopIsPowerBadge": false,
    "gaKey": "handphone-tablet/aksesoris-handphone/soft-case-handphone",
    "sourceEngine": "",
    "searchKeyword": "iphone 15",
    "searchUrl": "https://www.tokopedia.com/search?q=iphone+15&ob=23&source=search",
    "scrapedAt": "2026-06-26T10:30:00.000Z"
}
````

### Performance & Pricing

| Metric | Typical Value |
|---|---|
| Speed | ~1–2 seconds per page (60 results) |
| 100 results | ~3–5 seconds |
| 1,000 results | ~20–30 seconds |
| Memory usage | ~200–400 MB |
| Cost per 1,000 results | ~$0.03–0.08 (platform usage) |

Datacenter proxies are included in the default configuration and work well for most use cases. Residential proxies are available but rarely needed — this scraper's mobile header emulation bypasses the bot detection that typically requires residential IPs.

### How It Works — Technical Overview

The scraper sends HTTP POST requests directly to Tokopedia's product search endpoint with iOS mobile-device headers. This approach:

1. **Bypasses bot detection** — Tokopedia's desktop site uses browser fingerprinting that blocks automated requests. The mobile API path, when called with proper iOS device headers (User-Agent, X-Device, Bd-Device-Id, etc.), responds normally.
2. **Returns structured JSON** — No HTML parsing needed. The response is clean, typed GraphQL JSON.
3. **Paginates efficiently** — Each request returns up to 60 products. The scraper follows page numbers until reaching the limit or exhausting results.
4. **Deduplicates across pages** — Product IDs are tracked; duplicates from ranking shifts between pages are silently dropped.

### Tips for Best Results

- **Use specific keywords** — "iphone 15 pro max case" gives more targeted results than "case". Tokopedia's search is keyword-based; precise queries yield better data.
- **Start small, then scale** — Test with `maxItemsPerSearch: 60` first to verify data quality for your keyword. Then increase to 500+ for full extraction.
- **Combine with sorting** — Sort by "top sales" (`sortOrder: 8`) to find bestsellers. Sort by "newest" (`sortOrder: 5`) to discover recently listed products.
- **Run multiple keywords** — One run can search 10, 20, or more keywords. Ideal for category-wide research — just list all your target keywords in `searchKeywords`.
- **Schedule for monitoring** — Use Apify Schedules to run daily or weekly searches. Track new products, price changes, and rating shifts over time.
- **Export to your stack** — Apify integrations let you push results to Google Sheets, Airtable, Notion, SQL databases, S3, or any REST API webhook.

### Limitations

- **Public search results only** — This scraper extracts what Tokopedia shows in public search. Seller-private data, order volumes, and exact inventory counts are not available.
- **Search API fields** — The public API does not expose the "sold count" field (typically shown as "Terjual 100+"). We extract all available structured fields; some display-only labels are not present in the API response.
- **Rate limits** — Tokopedia may throttle excessive requests. The scraper includes exponential backoff and retry logic. For very large extractions (>5,000 results), spread across multiple runs or add delays.
- **Indonesian marketplace** — Tokopedia primarily serves Indonesia. Products are listed in Indonesian (Bahasa Indonesia). Non-Indonesian keywords may return limited results.

### Legal & Responsible Use

This scraper extracts publicly available product information from Tokopedia. It does not access private accounts, bypass authentication, or scrape personal data.

To use this scraper responsibly:

- Comply with Tokopedia's Terms of Service
- Respect rate limits — don't overwhelm their servers
- Use extracted data in compliance with applicable laws
- This tool is for legitimate market research, competitive analysis, and academic use

***

**Made for serious e-commerce data users** — researchers, analysts, brand owners, and developers who need reliable Tokopedia data at scale without the cost and complexity of browser-based scraping.

# Actor input Schema

## `searchKeywords` (type: `array`):

Product keywords to search on Tokopedia, e.g. 'iphone 15', 'sepatu nike', 'kursi kantor'. Each keyword runs a separate search. Combine with maxItems to control volume.

## `startUrls` (type: `array`):

Direct Tokopedia search or category URLs to scrape. Paste full URLs from tokopedia.com/search or category pages.

## `maxItemsPerSearch` (type: `integer`):

Maximum number of products to extract per keyword/URL. Tokopedia returns up to 60 results per page. Default 100, set 0 for no limit.

## `maxTotalItems` (type: `integer`):

Global cap across all keywords/URLs. 0 = unlimited.

## `rowsPerPage` (type: `integer`):

Results per API request (max 60). Higher = fewer requests but slightly slower per page.

## `sortOrder` (type: `string`):

How Tokopedia sorts results. '23' = relevance (default), '5' = newest, '8' = top sales, '11' = price low-high, '10' = price high-low, '9' = rating.

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

Proxy settings. Tokopedia GraphQL API is generally accessible without proxy. Enable residential proxy for large-scale extractions to avoid rate limits.

## Actor input object example

```json
{
  "searchKeywords": [
    "laptop asus",
    "sepatu adidas"
  ],
  "startUrls": [
    "https://www.tokopedia.com/search?q=laptop"
  ],
  "maxItemsPerSearch": 100,
  "maxTotalItems": 0,
  "rowsPerPage": 60,
  "sortOrder": "23",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `id` (type: `string`):

Tokopedia product ID

## `name` (type: `string`):

Product title/name

## `url` (type: `string`):

Product page URL on tokopedia.com

## `price` (type: `string`):

Display price (e.g. Rp370.000)

## `priceRaw` (type: `string`):

Numeric price in Indonesian Rupiah

## `originalPrice` (type: `string`):

Pre-discount price if discounted

## `originalPriceRaw` (type: `string`):

Numeric pre-discount price in IDR

## `discountPercentage` (type: `string`):

Discount percentage (0-100)

## `priceRange` (type: `string`):

Price range string for multi-variant products

## `rating` (type: `string`):

Numeric rating score

## `ratingAverage` (type: `string`):

Average star rating (1-5)

## `countReview` (type: `string`):

Number of customer reviews

## `wishlist` (type: `string`):

Whether product is on wishlist

## `imageUrl` (type: `string`):

Main product image URL

## `videoUrl` (type: `string`):

Product video URL if available

## `categoryId` (type: `string`):

Tokopedia category ID

## `categoryName` (type: `string`):

Category name

## `categoryBreadcrumb` (type: `string`):

Full category path (e.g. handphone-tablet/aksesoris)

## `shopId` (type: `string`):

Seller shop ID

## `shopName` (type: `string`):

Seller shop name

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

Seller shop URL on tokopedia.com

## `shopCity` (type: `string`):

Seller location city

## `shopIsOfficial` (type: `string`):

Whether an official brand store

## `shopIsPowerBadge` (type: `string`):

Power seller badge status

## `gaKey` (type: `string`):

Google Analytics category key

## `sourceEngine` (type: `string`):

Search source engine identifier

## `searchKeyword` (type: `string`):

The keyword used for this search result

## `searchUrl` (type: `string`):

The search URL that produced this result

## `scrapedAt` (type: `string`):

ISO 8601 timestamp of extraction

# 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 = {
    "searchKeywords": [
        "iphone 15"
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/tokopedia-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 = {
    "searchKeywords": ["iphone 15"],
    "startUrls": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/tokopedia-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 '{
  "searchKeywords": [
    "iphone 15"
  ],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/tokopedia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tokopedia Scraper — Indonesia #1 Marketplace Product Search",
        "description": "Scrape Tokopedia product search results by keyword or URL. Extract product name, price, rating, review count, discount, shop info, category breadcrumb, and images. Pure HTTP GraphQL API — fast, low-cost, no browser overhead. Perfect for market research, competitor monitoring, and lead generation.",
        "version": "0.1",
        "x-build-id": "JK3zgAtMHMfvK56mK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~tokopedia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-tokopedia-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/haketa~tokopedia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-tokopedia-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/haketa~tokopedia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-tokopedia-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchKeywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Product keywords to search on Tokopedia, e.g. 'iphone 15', 'sepatu nike', 'kursi kantor'. Each keyword runs a separate search. Combine with maxItems to control volume.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct Tokopedia search or category URLs to scrape. Paste full URLs from tokopedia.com/search or category pages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerSearch": {
                        "title": "Max items per search",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to extract per keyword/URL. Tokopedia returns up to 60 results per page. Default 100, set 0 for no limit.",
                        "default": 100
                    },
                    "maxTotalItems": {
                        "title": "Max total items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Global cap across all keywords/URLs. 0 = unlimited.",
                        "default": 0
                    },
                    "rowsPerPage": {
                        "title": "Rows per page",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Results per API request (max 60). Higher = fewer requests but slightly slower per page.",
                        "default": 60
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "23",
                            "5",
                            "8",
                            "11",
                            "10",
                            "9"
                        ],
                        "type": "string",
                        "description": "How Tokopedia sorts results. '23' = relevance (default), '5' = newest, '8' = top sales, '11' = price low-high, '10' = price high-low, '9' = rating.",
                        "default": "23"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Tokopedia GraphQL API is generally accessible without proxy. Enable residential proxy for large-scale extractions to avoid rate limits.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
