# Shopee Scraper (`khadinakbar/shopee-scraper`) Actor

Scrape Shopee product search results and product detail pages across Singapore, Malaysia, Philippines, Thailand, Vietnam, Indonesia, Brazil, Mexico, and Taiwan. Returns flat MCP-ready product records with price, sales, ratings, stock, seller, and product URLs.

- **URL**: https://apify.com/khadinakbar/shopee-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, AI
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Shopee Scraper

Scrape Shopee product search results and product detail pages across major Shopee marketplaces with flat, MCP-ready JSON output for price monitoring, seller intelligence, marketplace research, and AI-agent workflows.

The actor supports Shopee Singapore, Malaysia, Philippines, Thailand, Vietnam, Indonesia, Brazil, Mexico, and Taiwan. It accepts keyword searches and Shopee URLs, then returns one product record per item with price, rating, sales, stock, seller, image, and source metadata.

### What It Extracts

| Field | Description |
| --- | --- |
| `productId`, `shopId` | Shopee item and shop identifiers when available |
| `productUrl` | Canonical Shopee product URL |
| `title` | Product title |
| `price`, `priceMin`, `priceMax` | Current price and variant price range |
| `priceBeforeDiscount`, `discount` | Original price and discount label |
| `currency` | Marketplace currency such as SGD, MYR, PHP, THB, VND, IDR, BRL, MXN, or TWD |
| `rating`, `ratingCount` | Product rating signals |
| `sold`, `historicalSold` | Recent and historical sold counts when Shopee exposes them |
| `stock` | Available stock when returned by the product payload |
| `shopName`, `shopLocation` | Seller identity and location |
| `isOfficialShop`, `isShopeeMall` | Seller quality flags when available |
| `imageUrl` | Main product image URL |
| `description` | Product description when detail extraction is enabled |
| `categories` | Category breadcrumbs when available |

### When To Use It

Use this actor for e-commerce teams, marketplace sellers, agencies, and analysts who need Shopee product data for competitor price tracking, assortment research, seller benchmarking, stock monitoring, and category intelligence.

Use keyword searches when you want a broad product list:

```json
{
  "providerMode": "scrapeless",
  "country": "SG",
  "searchQueries": ["wireless earbuds", "mechanical keyboard"],
  "maxProducts": 100,
  "maxSearchPages": 3,
  "includeDetails": true
}
````

Use start URLs when you already have Shopee product, search, category, or shop URLs:

```json
{
  "providerMode": "scrapeless",
  "country": "PH",
  "startUrls": [
    { "url": "https://shopee.ph/search?keyword=sunscreen" },
    { "url": "https://shopee.ph/product/123456/987654321" }
  ],
  "maxProducts": 50
}
```

### When Not To Use It

This actor is not a review scraper, checkout automation tool, private account scraper, coupon redeemer, or order-management integration. It does not log in to Shopee accounts and it does not bypass paywalled or private user data.

Shopee changes anti-bot defenses often. The actor uses browser-backed extraction and residential proxy defaults, but heavily challenged regions or temporary Shopee outages can still produce partial results or warning summaries.

### Input Options

| Input | Default | Notes |
| --- | --- | --- |
| `providerMode` | `auto` | `scrapeless` uses `SCRAPELESS_API_KEY`, `owned` uses browser scraping, `auto` uses Scrapeless when configured |
| `country` | `SG` | Marketplace domain and currency selector |
| `searchQueries` | `["wireless earbuds"]` | One or more keyword searches |
| `startUrls` | empty | Shopee product, search, category, or shop URLs |
| `maxProducts` | `50` | Hard cap on returned and charged product records |
| `maxSearchPages` | `3` | Pagination cap for generated keyword search URLs |
| `includeDetails` | `true` | Visits product pages when listing data is incomplete |
| `sortBy` | `relevance` | `relevance`, `latest`, or `top_sales` |
| `includeRawData` | `false` | Adds trimmed raw Shopee payloads for debugging |

### Output Example

```json
{
  "productId": "131564786",
  "shopId": "22739277",
  "productUrl": "https://shopee.sg/product/22739277/131564786",
  "title": "Wireless Bluetooth Earbuds",
  "price": 19.9,
  "priceMin": 15.9,
  "priceMax": 24.9,
  "priceBeforeDiscount": 29.9,
  "currency": "SGD",
  "discount": "20%",
  "rating": 4.8,
  "ratingCount": 1240,
  "sold": 5000,
  "historicalSold": 15000,
  "stock": 98,
  "shopName": "Shopee Mall Store",
  "shopLocation": "Singapore",
  "isOfficialShop": true,
  "isShopeeMall": true,
  "imageUrl": "https://down-sg.img.susercontent.com/file/example",
  "description": "Bluetooth earbuds with charging case.",
  "categories": ["Mobile & Gadgets", "Audio"],
  "sourceType": "search",
  "sourceUrl": "https://shopee.sg/search?keyword=wireless%20earbuds",
  "scrapedAt": "2026-06-12T08:00:00.000Z"
}
```

### Pricing

| Event | Price |
| --- | --- |
| Actor start | `$0.00005` |
| Product scraped | `$0.07` per product |

A run capped at 100 products costs at most about `$7.00` in product events, plus the small actor start event and Apify platform usage. The actor prints the cost cap at run start and stops charging after `maxProducts`.

### MCP And AI Agent Notes

The actor is designed for Apify MCP and agent workflows. Inputs are narrow, output fields are flat, and every product item keeps stable semantic keys. Use it when an agent needs Shopee product intelligence; do not route generic Amazon, Lazada, TikTok Shop, or review-only tasks here.

### Reliability Notes

Shopee data is loaded dynamically and is protected by anti-bot systems in some regions. The recommended production backend is Scrapeless, configured with the `SCRAPELESS_API_KEY` actor secret and `providerMode: "scrapeless"`. The owned browser backend remains available for diagnostics and future hardening, but current Shopee anti-bot responses can block it. If Shopee or the provider returns a challenge, the run records warnings in `OUTPUT` and `RUN_SUMMARY` instead of silently pretending empty data is complete.

For best results:

- Keep `maxProducts` realistic for the first run.
- Configure `SCRAPELESS_API_KEY` before using provider-backed production mode.
- Use country-specific Shopee URLs that match the selected country.
- Use residential proxies for cloud runs.
- Enable `includeRawData` only for debugging.

### Legal And Compliance

This actor extracts publicly available Shopee product information. You are responsible for using the data in compliance with Shopee terms, applicable laws, privacy requirements, and marketplace rules. Do not use this actor for account abuse, checkout automation, spam, or collection of private user information.

# Actor input Schema

## `providerMode` (type: `string`):

Use this when choosing the Shopee extraction backend. auto uses SCRAPELESS\_API\_KEY when configured, then owned browser scraping; scrapeless requires that actor secret and is the recommended production path. Defaults to auto for safer setup. This is not a Shopee login mode.

## `country` (type: `string`):

Use this when selecting the Shopee marketplace domain to scrape. Accepted values include SG, MY, PH, TH, VN, ID, BR, MX, and TW. Defaults to SG and controls currency, locale, and generated search URLs. This is not a shipping destination filter inside Shopee.

## `searchQueries` (type: `array`):

Use this when you want Shopee search result products from keywords such as wireless earbuds or korean sunscreen. Enter one query per line; the actor builds Shopee search URLs for the selected country. Defaults to an empty list and works together with Start URLs. This is not for seller IDs or review scraping.

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

Use this when you already have Shopee product, search, category, or shop search URLs. Accepted format is a Shopee URL such as https://shopee.sg/search?keyword=keyboard or https://shopee.sg/product/22739277/131564786. Defaults to an empty list and can be combined with Search queries. This is not for non-Shopee marketplace URLs.

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

Use this to cap the number of product records returned and charged. Accepted range is 1 to 1000 products, with 50 as the default. The actor stops charging once this cap is reached. This is not a page count.

## `maxSearchPages` (type: `integer`):

Use this when scraping keyword, category, or shop listing pages that need pagination. Accepted range is 1 to 20 pages, with 3 as the default. Higher values may take longer because Shopee rate limits aggressively. This does not increase results beyond Maximum products.

## `includeDetails` (type: `boolean`):

Use this when you want detail-page fields such as description, stock, variants, and richer seller data. Defaults to true and visits product detail URLs when search data is incomplete. Turn it off for faster listing-only monitoring. This is not review extraction.

## `sortBy` (type: `string`):

Use this when Shopee search results should be ordered by relevance, latest, or top sales. Accepted values are relevance, latest, and top\_sales; default is relevance. This applies only to generated keyword search URLs. This is not a filter for price or rating.

## `includeRawData` (type: `boolean`):

Use this for debugging Shopee schema changes or building custom downstream parsers. Defaults to false to keep MCP output compact and stable. When true, each record may include a trimmed rawData object from Shopee responses. This is not needed for normal product exports.

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

Use this only when you need custom Apify Proxy groups or a country-specific proxy setup. Defaults to Apify residential proxy settings because Shopee blocks many datacenter sessions. Leave unchanged for normal runs. This is not a Shopee account or cookie setting.

## Actor input object example

```json
{
  "providerMode": "auto",
  "country": "SG",
  "searchQueries": [
    "wireless earbuds"
  ],
  "startUrls": [
    {
      "url": "https://shopee.sg/search?keyword=wireless%20earbuds"
    }
  ],
  "maxProducts": 50,
  "maxSearchPages": 3,
  "includeDetails": true,
  "sortBy": "relevance",
  "includeRawData": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "startUrls": [
        {
            "url": "https://shopee.sg/search?keyword=wireless%20earbuds"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/shopee-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 = { "startUrls": [{ "url": "https://shopee.sg/search?keyword=wireless%20earbuds" }] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/shopee-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 '{
  "startUrls": [
    {
      "url": "https://shopee.sg/search?keyword=wireless%20earbuds"
    }
  ]
}' |
apify call khadinakbar/shopee-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopee Scraper",
        "description": "Scrape Shopee product search results and product detail pages across Singapore, Malaysia, Philippines, Thailand, Vietnam, Indonesia, Brazil, Mexico, and Taiwan. Returns flat MCP-ready product records with price, sales, ratings, stock, seller, and product URLs.",
        "version": "0.1",
        "x-build-id": "tTdSzKHyDVdrY7sv4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~shopee-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-shopee-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/khadinakbar~shopee-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-shopee-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/khadinakbar~shopee-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-shopee-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": {
                    "providerMode": {
                        "title": "Provider mode",
                        "enum": [
                            "auto",
                            "owned",
                            "scrapeless"
                        ],
                        "type": "string",
                        "description": "Use this when choosing the Shopee extraction backend. auto uses SCRAPELESS_API_KEY when configured, then owned browser scraping; scrapeless requires that actor secret and is the recommended production path. Defaults to auto for safer setup. This is not a Shopee login mode.",
                        "default": "auto"
                    },
                    "country": {
                        "title": "Shopee country",
                        "enum": [
                            "SG",
                            "MY",
                            "PH",
                            "TH",
                            "VN",
                            "ID",
                            "BR",
                            "MX",
                            "TW"
                        ],
                        "type": "string",
                        "description": "Use this when selecting the Shopee marketplace domain to scrape. Accepted values include SG, MY, PH, TH, VN, ID, BR, MX, and TW. Defaults to SG and controls currency, locale, and generated search URLs. This is not a shipping destination filter inside Shopee.",
                        "default": "SG"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Use this when you want Shopee search result products from keywords such as wireless earbuds or korean sunscreen. Enter one query per line; the actor builds Shopee search URLs for the selected country. Defaults to an empty list and works together with Start URLs. This is not for seller IDs or review scraping.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "wireless earbuds"
                        ]
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Use this when you already have Shopee product, search, category, or shop search URLs. Accepted format is a Shopee URL such as https://shopee.sg/search?keyword=keyboard or https://shopee.sg/product/22739277/131564786. Defaults to an empty list and can be combined with Search queries. This is not for non-Shopee marketplace URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxProducts": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Use this to cap the number of product records returned and charged. Accepted range is 1 to 1000 products, with 50 as the default. The actor stops charging once this cap is reached. This is not a page count.",
                        "default": 50
                    },
                    "maxSearchPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Use this when scraping keyword, category, or shop listing pages that need pagination. Accepted range is 1 to 20 pages, with 3 as the default. Higher values may take longer because Shopee rate limits aggressively. This does not increase results beyond Maximum products.",
                        "default": 3
                    },
                    "includeDetails": {
                        "title": "Include product details",
                        "type": "boolean",
                        "description": "Use this when you want detail-page fields such as description, stock, variants, and richer seller data. Defaults to true and visits product detail URLs when search data is incomplete. Turn it off for faster listing-only monitoring. This is not review extraction.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Search sort",
                        "enum": [
                            "relevance",
                            "latest",
                            "top_sales"
                        ],
                        "type": "string",
                        "description": "Use this when Shopee search results should be ordered by relevance, latest, or top sales. Accepted values are relevance, latest, and top_sales; default is relevance. This applies only to generated keyword search URLs. This is not a filter for price or rating.",
                        "default": "relevance"
                    },
                    "includeRawData": {
                        "title": "Include raw data",
                        "type": "boolean",
                        "description": "Use this for debugging Shopee schema changes or building custom downstream parsers. Defaults to false to keep MCP output compact and stable. When true, each record may include a trimmed rawData object from Shopee responses. This is not needed for normal product exports.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use this only when you need custom Apify Proxy groups or a country-specific proxy setup. Defaults to Apify residential proxy settings because Shopee blocks many datacenter sessions. Leave unchanged for normal runs. This is not a Shopee account or cookie setting.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
