# TikTok Shop Search Pro 🔥 (`sentry/tiktok-shop-search-pro`) Actor

TikTok Shop scraper for keyword and region search. Extract product IDs, titles, brands, sellers, prices, ratings, reviews, SKU pricing, and ranking data in clean structured output for ecommerce research, competitor tracking, trend discovery, and product sourcing.

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

## Pricing

from $25.00 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## TikTok Shop Search Pro

**TikTok Shop Search Pro** is an advanced **TikTok Shop scraper** for high-quality keyword search extraction, product intelligence, and ecommerce analysis.

If you need structured **TikTok Shop product data** for market research, competitor tracking, trend discovery, or catalog analysis, this Actor is built for that workflow.

It helps you scrape TikTok Shop search results with clean output you can send directly to dashboards, sheets, BI tools, or internal data pipelines.

### Why This TikTok Shop Scraper

Most teams need the same core outcome: reliable TikTok Shop search data that is actually usable for decision-making.

This Actor focuses on that:

- Keyword-based TikTok Shop scraping
- Region-aware search collection
- Product deduplication across result pages
- Pricing and ranking fields normalized for analysis
- Clean output for reporting and automation
- Flexible options for lightweight or deep extraction

Whether you are running one-off product discovery or daily monitoring jobs, TikTok Shop Search Pro is designed for repeatable data collection.

### What You Can Do With It

#### 1) TikTok Shop Product Research
Search by niche keyword (for example: wireless earbuds, ergonomic chair, gym leggings) and quickly review product landscape, pricing, and positioning.

#### 2) Ecommerce Competitor Intelligence
Track brands and sellers appearing for target search terms. Compare rank positions, pricing patterns, and listing activity across runs.

#### 3) Trend & Demand Discovery
Identify recurring products and category movement over time. Use repeated snapshots to detect emerging or declining search opportunities.

#### 4) Pricing Analysis
Collect min, max, and average price signals for products and SKU variants. Build your own pricing benchmarks and change alerts.

#### 5) Dropshipping & Sourcing Validation
Validate product viability by checking search presence, rating signals, and listing saturation before spending on inventory or ads.

#### 6) Agency & Client Reporting
Export normalized data to client-facing reports for product research, market scans, and keyword opportunity tracking.

### Data Fields Included

For each discovered product, you can collect fields like:

- Search context: `query`, `page`, `rank_on_page`, `rank_global`
- Product identity: `product_id`, `product_name`, `product_name_slug`, `product_url`
- Seller and brand: `seller`, `brand_name`
- Pricing: `min_price`, `max_price`, `avg_price`, `real_price`, `currency_symbol`, `currency_name`
- Social proof: `product_rating`, `review_count`
- SKU details: `skus[]`, `sku_count` (when present)
- Traceability: `source_url`, `scraped_at`
- Optional raw payload: `raw_product` (if enabled)

Some extended business metrics may appear for certain listings and may be absent for others depending on source payload availability.

### Input Parameters (Practical Guide)

#### Search & Scope

- `queries` (required)  
  One or more search keywords. Example: `["wireless earbuds", "gaming chair"]`

- `searchRegion`  
  Regional search context (for example `US`, `GB`, `CA`).

- `maxPagesPerQuery`  
  Maximum number of search pages to scan per keyword.

- `maxResultsPerQuery`  
  Maximum unique products returned per keyword.

#### Output Format

- `includeRawProduct`  
  Adds full raw payload to each record for advanced custom parsing.

- `compactNullFields`  
  Cleaner output mode. Removes empty/null keys to keep datasets lean.

#### Reliability Controls

- `requestTimeoutSec`  
  Request timeout per page.

- `maxFetchRetries`  
  Retries per page request.

- `queryRetryAttempts`  
  Query-level retries for unstable result loads.

- `allowDirectRescueOnSoftBlock`  
  Extra recovery pass for difficult responses.

- `enableBrowserFallback`  
  Optional enhanced compatibility mode.

- `browserFallbackWaitMs`  
  Wait time used by compatibility mode.

- `failOnZeroAfterRetries`  
  If enabled, run fails when retries still return zero products.

#### Proxy

- `proxyConfiguration`  
  Uses Apify’s built-in proxy selector (residential/datacenter/custom) depending on your collection strategy.

### Recommended Starting Configuration

If you want stable, balanced collection for most keywords:

- `maxPagesPerQuery`: `3`
- `maxResultsPerQuery`: `200`
- `compactNullFields`: `true`
- `maxFetchRetries`: `3`
- `queryRetryAttempts`: `3`
- `allowDirectRescueOnSoftBlock`: `true`

Then tune upward only after validating consistency and cost for your target niche.

### Example Input

```json
{
  "queries": ["wireless earbuds", "ergonomic chair"],
  "searchRegion": "US",
  "maxPagesPerQuery": 3,
  "maxResultsPerQuery": 200,
  "includeRawProduct": false,
  "compactNullFields": true,
  "maxFetchRetries": 3,
  "queryRetryAttempts": 3,
  "allowDirectRescueOnSoftBlock": true
}
````

### Example Output (Truncated)

```json
{
  "query": "ergonomic chair",
  "rank_global": 1,
  "product_id": "1729385482393260168",
  "product_name": "Sweet Furniture Ergonomic Office Chair...",
  "brand_name": "Sweetcrispy",
  "seller": "Sweet Furniture",
  "min_price": 79.99,
  "max_price": 85.99,
  "avg_price": 83.49,
  "currency_symbol": "$",
  "product_rating": 4.5,
  "review_count": 5266,
  "product_url": "https://www.tiktok.com/shop/product/...",
  "source_url": "https://www.tiktok.com/shop/s?q=ergonomic+chair&region=US&page=1",
  "scraped_at": "2026-03-22T23:10:19.000Z"
}
```

### Ideal Users

- Ecommerce operators
- TikTok Shop growth teams
- Product research analysts
- Performance marketing teams
- Dropshipping and sourcing teams
- Agencies managing TikTok Shop accounts
- Data teams building marketplace intelligence tools

### SEO & Market Intent Coverage

This Actor targets high-intent TikTok Shop data workflows, including:

- TikTok Shop scraper
- TikTok Shop search scraper
- TikTok Shop product scraper
- TikTok Shop keyword scraper
- TikTok ecommerce data scraper
- TikTok Shop competitor analysis tool
- TikTok Shop product research tool
- TikTok Shop price tracker
- TikTok Shop catalog intelligence
- TikTok Shop trend tracking

### Tips for Better Results

- Use focused keyword batches by category instead of huge mixed keyword lists.
- Run scheduled scans to build historical trend visibility.
- Keep `compactNullFields` enabled for cleaner downstream reporting.
- Compare repeated runs to spot ranking and pricing movement.
- Split heavy queries into multiple runs for better operational control.

### FAQ

#### Why are some optional fields missing on certain products?

TikTok Shop payloads can vary by listing and context. Core product, pricing, and ranking fields are usually most consistent.

#### Can I use this for daily monitoring?

Yes. It is suitable for recurring runs and historical comparison workflows.

#### Is this useful for competitor tracking?

Yes. You can monitor sellers, brands, pricing, and rank visibility by keyword over time.

#### Can I export to my analytics stack?

Yes. Dataset output is structured for easy export to BI tools, spreadsheets, and custom pipelines.

### Final Note

If your goal is to build a serious **TikTok Shop product intelligence** workflow, this Actor gives you a clean, scalable base for keyword scraping, competitive research, and ecommerce decision-making.

# Actor input Schema

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

Keywords to search on TikTok Shop (for example: "ergo chair", "phone case"). One dataset item is emitted per discovered product.

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

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

## `maxPagesPerQuery` (type: `integer`):

Maximum number of search-result pages to request per query. The crawler also stops early when no new results are found.

## `maxResultsPerQuery` (type: `integer`):

Upper limit of unique products collected per query.

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

Include the full raw product object in each dataset item. Disable this if you want smaller output payloads.

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

If true, omit fields that are null/undefined from output records to keep datasets cleaner.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel HTTP requests.

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

HTTP request timeout for each page request.

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

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

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

How many full retries to run for a query when blocked/failure signals produce zero results.

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

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

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

If a page is blocked/challenged and Cheerio extracts zero products, try a minimal Playwright fetch as a fallback.

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

How long the Playwright fallback waits after page load before reading HTML.

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

If true, fail the run when all queries still return zero products after retry logic.

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

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

## Actor input object example

```json
{
  "queries": [
    "ergo chair"
  ],
  "searchRegion": "US",
  "maxPagesPerQuery": 3,
  "maxResultsPerQuery": 200,
  "includeRawProduct": true,
  "compactNullFields": true,
  "maxConcurrency": 5,
  "requestTimeoutSec": 30,
  "maxFetchRetries": 3,
  "queryRetryAttempts": 3,
  "allowDirectRescueOnSoftBlock": true,
  "enableBrowserFallback": true,
  "browserFallbackWaitMs": 8000,
  "failOnZeroAfterRetries": false
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "ergo chair"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sentry/tiktok-shop-search-pro").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "queries": ["ergo chair"] }

# Run the Actor and wait for it to finish
run = client.actor("sentry/tiktok-shop-search-pro").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "ergo chair"
  ]
}' |
apify call sentry/tiktok-shop-search-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Search Pro 🔥",
        "description": "TikTok Shop scraper for keyword and region search. Extract product IDs, titles, brands, sellers, prices, ratings, reviews, SKU pricing, and ranking data in clean structured output for ecommerce research, competitor tracking, trend discovery, and product sourcing.",
        "version": "1.0",
        "x-build-id": "qxvaggQr7v8axIH0A"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sentry~tiktok-shop-search-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sentry-tiktok-shop-search-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sentry~tiktok-shop-search-pro/runs": {
            "post": {
                "operationId": "runs-sync-sentry-tiktok-shop-search-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sentry~tiktok-shop-search-pro/run-sync": {
            "post": {
                "operationId": "run-sync-sentry-tiktok-shop-search-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords to search on TikTok Shop (for example: \"ergo chair\", \"phone case\"). One dataset item is emitted per discovered product.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchRegion": {
                        "title": "Search Region",
                        "type": "string",
                        "description": "Region parameter sent to TikTok Shop search page (for example: US, GB).",
                        "default": "US"
                    },
                    "maxPagesPerQuery": {
                        "title": "Max Pages Per Query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of search-result pages to request per query. The crawler also stops early when no new results are found.",
                        "default": 3
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results Per Query",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Upper limit of unique products collected per query.",
                        "default": 200
                    },
                    "includeRawProduct": {
                        "title": "Include Raw Product Payload",
                        "type": "boolean",
                        "description": "Include the full raw product object in each dataset item. Disable this if you want smaller output payloads.",
                        "default": true
                    },
                    "compactNullFields": {
                        "title": "Compact Null Fields",
                        "type": "boolean",
                        "description": "If true, omit fields that are null/undefined from output records to keep datasets cleaner.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of parallel HTTP requests.",
                        "default": 5
                    },
                    "requestTimeoutSec": {
                        "title": "Request Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP request timeout for each page request.",
                        "default": 30
                    },
                    "maxFetchRetries": {
                        "title": "Max Fetch Retries",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many HTTP fetch attempts to try per page before giving up.",
                        "default": 3
                    },
                    "queryRetryAttempts": {
                        "title": "Full Query Retry Attempts",
                        "minimum": 3,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many full retries to run for a query when blocked/failure signals produce zero results.",
                        "default": 3
                    },
                    "allowDirectRescueOnSoftBlock": {
                        "title": "Allow Direct Rescue On Soft-Block",
                        "type": "boolean",
                        "description": "When proxy pages are soft-blocked, try one direct (no-proxy) fetch rescue before giving up that page.",
                        "default": true
                    },
                    "enableBrowserFallback": {
                        "title": "Enable Browser Fallback On Block",
                        "type": "boolean",
                        "description": "If a page is blocked/challenged and Cheerio extracts zero products, try a minimal Playwright fetch as a fallback.",
                        "default": true
                    },
                    "browserFallbackWaitMs": {
                        "title": "Browser Fallback Wait (ms)",
                        "minimum": 1000,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "How long the Playwright fallback waits after page load before reading HTML.",
                        "default": 8000
                    },
                    "failOnZeroAfterRetries": {
                        "title": "Fail Run If Zero After Retries",
                        "type": "boolean",
                        "description": "If true, fail the run when all queries still return zero products after retry logic.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Choose proxy type and settings (Apify Proxy residential/datacenter or custom proxies)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```