# TikTok Shop Similar Products (`sentry/tiktok-shop-similar-products`) Actor

Find similar, competing, substitute, cheaper, premium, and related TikTok Shop products from a product URL, product title, or keyword seed.

- **URL**: https://apify.com/sentry/tiktok-shop-similar-products.md
- **Developed by:** [Sentry](https://apify.com/sentry) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## 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 Similar Products

Find similar TikTok Shop products, competing listings, substitute products, cheaper alternatives, premium alternatives, and related product ideas from a TikTok Shop product URL, product title, or keyword seed.

This actor is built for TikTok Shop sellers, ecommerce operators, product researchers, affiliate teams, creator-commerce teams, agencies, dropshipping researchers, brand managers, and competitive intelligence workflows that need fast product comparison data.

### What this TikTok Shop scraper does

TikTok Shop Similar Products takes one or more seed products or keywords and returns a structured dataset of related TikTok Shop products. Each result includes a similarity score, relation type, match reasons, price, rating, review count, seller, brand, product URL, image URL, and public demand signals when available.

Use it to answer questions like:

- What products are similar to this TikTok Shop product?
- Which TikTok Shop listings compete with this product?
- What cheaper alternatives exist on TikTok Shop?
- What premium alternatives exist on TikTok Shop?
- What products are ranking around the same buyer intent?
- Which sellers are competing in this TikTok Shop niche?
- What substitute products could a buyer choose instead?
- Which similar products have ratings, reviews, sales signals, or visible demand?

### Common use cases

#### TikTok Shop competitor product research

Start with your own product URL, a competitor product URL, or a product keyword. The actor returns related listings so you can compare competing products, sellers, price bands, ratings, reviews, and positioning.

#### TikTok Shop product comparison

Build product comparison datasets for market research, sourcing, merchandising, affiliate planning, ad research, or category analysis. The output is designed for spreadsheets, BI tools, dashboards, and internal ecommerce workflows.

#### TikTok Shop alternatives and substitutes

Find cheaper alternatives, premium alternatives, near substitutes, direct alternatives, and broadly related products. This is useful when evaluating whether a product is differentiated or surrounded by close competitors.

#### TikTok Shop affiliate and creator-commerce research

Affiliate teams and creator-commerce teams can compare alternative products in the same niche before deciding what to promote, brief creators on, or test in campaigns.

#### TikTok Shop product validation

Before sourcing, launching, or promoting a product, use this actor to see whether similar products already have public demand signals, strong ratings, or crowded competition.

### Example inputs

Use TikTok Shop product URLs:

```json
{
    "seeds": [
        "https://www.tiktok.com/shop/pdp/ergonomic-office-chair-by-sweetfurniture-with-footrest-adjustable-headrest/1729385482393260168"
    ],
    "searchRegion": "US",
    "maxResultsPerSeed": 100
}
````

Use product titles or keywords:

```json
{
    "seeds": ["neck fan", "walking pad", "ergo chair"],
    "searchRegion": "US",
    "maxQueriesPerSeed": 4,
    "maxPagesPerQuery": 3
}
```

Apply quality filters:

```json
{
    "seeds": ["portable blender"],
    "minSimilarityScore": 60,
    "minRating": 4.3,
    "minReviewCount": 10,
    "maxPrice": 75
}
```

### Output fields

Core dataset fields include:

- `seed`: original product URL, title, or keyword
- `seed_type`: seed classification
- `seed_product_id`: product ID parsed from a TikTok Shop URL when available
- `source_query`: related TikTok Shop search query used for discovery
- `similarity_score`: 0-100 score for match strength
- `similarity_tier`: very-close, close, related, or loose
- `relation_type`: near-substitute, direct-alternative, related-product, or broadly-related
- `match_reasons`: readable reasons the product was selected
- `match_cautions`: warnings to review before treating the product as a close match
- `shared_terms`: overlapping product terms
- `price_position`: broad product price band
- `rating_strength`: rating/review quality label
- `demand_signal`: public demand signal label
- `product_id`: TikTok Shop product ID
- `product_name`: TikTok Shop product name
- `brand_name`: brand name when available
- `seller`: seller/store name
- `avg_price`, `min_price`, `max_price`: product price fields when available
- `product_rating`: public product rating
- `review_count`: public review count
- `sold_count`: public sold count when available
- `product_url`: TikTok Shop product URL
- `product_image_url`: product image URL
- `source_url`: TikTok Shop search URL used for the result
- `scraped_at`: collection timestamp

### Who this is for

- TikTok Shop sellers researching competitors and alternatives
- Ecommerce teams comparing product positioning and pricing
- Affiliate teams looking for products in the same niche
- Agencies preparing market or product research reports
- Dropshipping researchers validating product ideas
- Brand teams monitoring marketplace competition
- Product researchers building structured TikTok Shop datasets

### Tips for best results

- Use specific product names or TikTok Shop product URLs for tighter similar-product matches.
- Use broad keywords for larger niche discovery.
- Increase `maxQueriesPerSeed` to widen discovery around each seed.
- Increase `maxPagesPerQuery` for deeper TikTok Shop search coverage.
- Set `minSimilarityScore` to remove loose matches.
- Set `minReviewCount` or `minRating` when you only want validated products.
- Use `includeRawProduct` only when you need the underlying product payload for advanced analysis.

### FAQ

#### Can I use a TikTok Shop product URL as input?

Yes. You can provide TikTok Shop product URLs, product titles, or simple product keywords.

#### Does this return exact duplicates only?

No. It is designed to find similar products, substitutes, direct alternatives, related listings, and competing products around the same buyer intent.

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

Yes. The main use case is structured competitor product research: compare similar products by seller, price, rating, review count, sold count, and product URL.

#### Can this help with affiliate product research?

Yes. It can help affiliate and creator-commerce teams compare products in the same niche before choosing what to promote.

#### Does every result include sales and review data?

Only when that data is publicly available in the source result. Some TikTok Shop products expose more public fields than others.

### Notes

Results depend on public TikTok Shop availability, region, product visibility, and current search behavior. For important business decisions, review high-value matches manually before acting.

# Actor input Schema

## `seeds` (type: `array`):

TikTok Shop product URLs, product titles, or keyword seeds. The actor finds similar products, substitutes, competing listings, and related alternatives.

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

Region parameter sent to TikTok Shop search, for example US or GB.

## `maxQueriesPerSeed` (type: `integer`):

How many related TikTok Shop searches to run for each seed product or keyword.

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

Maximum number of TikTok Shop search-result pages to scan per generated search query.

## `maxResultsPerSeed` (type: `integer`):

Maximum similar-product records emitted per seed after filtering and sorting.

## `minSimilarityScore` (type: `integer`):

Only emit products at or above this 0-100 similarity score. Use 0 to keep all scored matches.

## `minRating` (type: `number`):

Optional minimum product rating. Products without a public rating are still allowed unless Require Reviews is enabled.

## `minReviewCount` (type: `integer`):

Only emit products with at least this many public reviews.

## `maxPrice` (type: `number`):

Optional maximum candidate product price.

## `requireReviews` (type: `boolean`):

If enabled, products with zero public reviews are excluded.

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

Include the raw TikTok Shop product object in each dataset item. Disable this for smaller output payloads.

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

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

## `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 generated search query when blocked/failure signals produce zero results.

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

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

## `forceMaxPages` (type: `boolean`):

If true, continue scanning until Max Pages Per Search Query even when a page appears exhausted.

## `requireAllQueryTokens` (type: `boolean`):

If true, each kept product must match all meaningful tokens in the generated search query.

## `minimumQueryTokenMatches` (type: `integer`):

Minimum number of generated query tokens that must appear in product title/slug fields when Require All Query Tokens is false.

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

Choose proxy type and settings. Residential proxies are recommended for TikTok Shop.

## Actor input object example

```json
{
  "seeds": [
    "https://www.tiktok.com/shop/pdp/ergonomic-office-chair-by-sweetfurniture-with-footrest-adjustable-headrest/1729385482393260168",
    "neck fan"
  ],
  "searchRegion": "US",
  "maxQueriesPerSeed": 4,
  "maxPagesPerQuery": 3,
  "maxResultsPerSeed": 200,
  "minSimilarityScore": 0,
  "minReviewCount": 0,
  "requireReviews": false,
  "includeRawProduct": false,
  "compactNullFields": true,
  "requestTimeoutSec": 30,
  "maxFetchRetries": 3,
  "queryRetryAttempts": 5,
  "failOnZeroAfterRetries": false,
  "forceMaxPages": true,
  "requireAllQueryTokens": false,
  "minimumQueryTokenMatches": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "seeds": [
        "https://www.tiktok.com/shop/pdp/ergonomic-office-chair-by-sweetfurniture-with-footrest-adjustable-headrest/1729385482393260168",
        "neck fan"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sentry/tiktok-shop-similar-products").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 = { "seeds": [
        "https://www.tiktok.com/shop/pdp/ergonomic-office-chair-by-sweetfurniture-with-footrest-adjustable-headrest/1729385482393260168",
        "neck fan",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sentry/tiktok-shop-similar-products").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 '{
  "seeds": [
    "https://www.tiktok.com/shop/pdp/ergonomic-office-chair-by-sweetfurniture-with-footrest-adjustable-headrest/1729385482393260168",
    "neck fan"
  ]
}' |
apify call sentry/tiktok-shop-similar-products --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Similar Products",
        "description": "Find similar, competing, substitute, cheaper, premium, and related TikTok Shop products from a product URL, product title, or keyword seed.",
        "version": "1.0",
        "x-build-id": "dY961iTTwBeVhAzuo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sentry~tiktok-shop-similar-products/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sentry-tiktok-shop-similar-products",
                "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-similar-products/runs": {
            "post": {
                "operationId": "runs-sync-sentry-tiktok-shop-similar-products",
                "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-similar-products/run-sync": {
            "post": {
                "operationId": "run-sync-sentry-tiktok-shop-similar-products",
                "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": {
                    "seeds": {
                        "title": "Seed Products or Keywords",
                        "type": "array",
                        "description": "TikTok Shop product URLs, product titles, or keyword seeds. The actor finds similar products, substitutes, competing listings, and related alternatives.",
                        "default": [
                            "neck fan",
                            "ergo chair"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchRegion": {
                        "title": "Search Region",
                        "type": "string",
                        "description": "Region parameter sent to TikTok Shop search, for example US or GB.",
                        "default": "US"
                    },
                    "maxQueriesPerSeed": {
                        "title": "Max Search Queries Per Seed",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many related TikTok Shop searches to run for each seed product or keyword.",
                        "default": 4
                    },
                    "maxPagesPerQuery": {
                        "title": "Max Pages Per Search Query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of TikTok Shop search-result pages to scan per generated search query.",
                        "default": 3
                    },
                    "maxResultsPerSeed": {
                        "title": "Max Similar Products Per Seed",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum similar-product records emitted per seed after filtering and sorting.",
                        "default": 200
                    },
                    "minSimilarityScore": {
                        "title": "Minimum Similarity Score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only emit products at or above this 0-100 similarity score. Use 0 to keep all scored matches.",
                        "default": 0
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Optional minimum product rating. Products without a public rating are still allowed unless Require Reviews is enabled."
                    },
                    "minReviewCount": {
                        "title": "Minimum Review Count",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Only emit products with at least this many public reviews.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional maximum candidate product price."
                    },
                    "requireReviews": {
                        "title": "Require Reviews",
                        "type": "boolean",
                        "description": "If enabled, products with zero public reviews are excluded.",
                        "default": false
                    },
                    "includeRawProduct": {
                        "title": "Include Raw Product Payload",
                        "type": "boolean",
                        "description": "Include the raw TikTok Shop product object in each dataset item. Disable this for smaller output payloads.",
                        "default": false
                    },
                    "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
                    },
                    "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": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many full retries to run for a generated search query when blocked/failure signals produce zero results.",
                        "default": 5
                    },
                    "failOnZeroAfterRetries": {
                        "title": "Fail Run If Zero After Retries",
                        "type": "boolean",
                        "description": "If true, fail the run when all seed searches still return zero products after retry logic.",
                        "default": false
                    },
                    "forceMaxPages": {
                        "title": "Force Max Pages",
                        "type": "boolean",
                        "description": "If true, continue scanning until Max Pages Per Search Query even when a page appears exhausted.",
                        "default": true
                    },
                    "requireAllQueryTokens": {
                        "title": "Require All Query Tokens",
                        "type": "boolean",
                        "description": "If true, each kept product must match all meaningful tokens in the generated search query.",
                        "default": false
                    },
                    "minimumQueryTokenMatches": {
                        "title": "Minimum Query Token Matches",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum number of generated query tokens that must appear in product title/slug fields when Require All Query Tokens is false.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Choose proxy type and settings. Residential proxies are recommended for TikTok Shop.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
