# TikTok Shop Reviews Scraper (`lurkapi/tiktok-shop-reviews-scraper`) Actor

Scrape TikTok Shop product reviews by product URL, product ID, or shop URL. Returns review text, rating, date, author, photos, and product context per row.

- **URL**: https://apify.com/lurkapi/tiktok-shop-reviews-scraper.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Automation, E-commerce, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 reviews scrapeds

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 Reviews Scraper

Pull reviews from any TikTok Shop product or shop. One row per review with rating, text, date, author, photos, and product context.

### 🎬 What it does

Give it a product URL, product ID, or shop URL and it will:
1. **Find the right reviews** for each product, using TikTok's own public review feed.
2. **Pull rating, text, date, reviewer name, photos, and SKU** for each review.
3. **Return one row per review** in a clean table you can sort and filter.

For shop URLs, the actor discovers the shop's products first, then pulls reviews for each of them.

### 📋 How to use it

#### Step 1: Paste your inputs
- **Product URLs**: copy them from any TikTok Shop product page (e.g. `https://www.tiktok.com/shop/pdp/_/1731349100249977343`).
- **Shop URLs**: paste numeric-ID shop links (e.g. `https://www.tiktok.com/shop/s/SHOP_ID`). @username links aren't supported; use the numeric form.
- **Product IDs**: paste the 18 to 19 digit number from a product URL.

You can mix all three in one run. Targets are deduplicated automatically.

#### Step 2: Configure how many reviews
- **Max reviews per product**: defaults to 50. No upper limit. TikTok itself stops serving the public feed somewhere around 2,000 to 2,400 reviews per product.
- **Max products per shop**: when scraping a shop, limits how many of its products will have reviews pulled.
- **Sort**: newest first, or recommended (TikTok's relevance ranking).
- **Star filter**: limit to a single rating (1 to 5), or 0 for all ratings.
- **Photos only**: returns only reviews with attached photos.

#### Step 3: Run it
Click Start and wait. Reviews appear in the Output tab as they're scraped, page by page.

#### Step 4: Get your results
Each row is one review. The `status` field tells you whether the scrape succeeded. The `error` field has details if it didn't. For shops, rows are tagged with the source shop ID so you can group by it.

### 💰 Pricing

Pay-per-review. You're billed only for reviews actually delivered to your dataset. Error rows and "no reviews" rows aren't billed.

### 💡 Good to know

- **Region**: United States only at launch. UK and other markets are on the roadmap.
- **Anonymous only**: no TikTok account is required and none is used. Some advanced filters TikTok offers to logged-in users aren't reachable this way.
- **Star filter and photo filter** are post-filters on top of the cap. If you set max=50 and photos-only=true, the actor keeps paginating until it has 50 photo reviews (or the feed runs dry), so you get exactly what you asked for when the supply exists.
- **Sort order**: TikTok's "recommended" tends to surface higher-quality reviews with photos earlier; "newest" gives strict chronological order.
- **Reviews depth**: TikTok caps how far back you can paginate. For products with thousands of reviews, the oldest may not be reachable.
- **First-seen**: this actor does not estimate product launch dates. Use the TikTok Shop Scraper for that.

### ❓ FAQ

**My product URL was skipped.**
The URL didn't match the supported pattern. Use a full `tiktok.com/shop/pdp/_/<id>` link or paste the product ID directly into Product IDs.

**My shop URL was skipped.**
@username links aren't supported. Use the numeric form: `tiktok.com/shop/s/<numeric-id>`. The numeric ID is usually visible in the URL when you click "View shop" on any product page.

**The product has 1,200 reviews but I only got 600.**
TikTok limits how deep the public review feed paginates. The actor returns everything reachable; the cap above that is set on TikTok's side.

**Are reviews real-time?**
Yes. Every run pulls live data from TikTok at the moment you click Start.

**How long are the results stored?**
In your Apify storage. Retention depends on your Apify plan.

### 🔗 Other tools you might like

- [TikTok Shop Scraper](https://apify.com/lurkapi/tiktok-shop-scraper): product data (title, price, sold count, ratings, seller info) for the same TikTok Shop catalog.
- [TikTok Profile Email Scraper](https://apify.com/lurkapi/tiktok-profile-email-scraper): find creator emails from TikTok profiles.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with TikTok's Terms of Service and applicable laws in your jurisdiction. The developer is not liable for misuse. Data availability depends on TikTok at run time.

**Keywords:** tiktok shop reviews, tiktok product reviews, tiktok shop scraper, review data, e-commerce reviews, customer reviews

# Actor input Schema

## `urls` (type: `array`):

Scrape reviews from product URLs (tiktok.com/shop/pdp/...) or shop URLs (tiktok.com/shop/s/SHOP_ID). Mix both; each is auto-detected. @username links aren't supported; use a URL with the numeric shop ID.
## `productIds` (type: `array`):

Scrape reviews for specific products by ID. The product ID is the 18-19 digit number in any product URL (e.g. 1731349100249977343). One per line.
## `maxReviewsPerTarget` (type: `integer`):

Cap on reviews returned per product. No upper limit; TikTok itself stops serving the public feed somewhere around 2,000-2,400 reviews per product.
## `maxProductsPerShop` (type: `integer`):

When a shop URL is provided, this caps how many of the shop's products will have their reviews scraped. Product URL inputs ignore this cap.
## `sortBy` (type: `string`):

How to order the reviews returned. 'newest' picks the most recent first; 'recommended' uses TikTok's relevance ranking (tends to surface higher-quality reviews with photos first).
## `starRating` (type: `integer`):

Limit reviews to one specific star rating (1 to 5). Use 0 (default) to return reviews of any rating.
## `withPhotosOnly` (type: `boolean`):

Return only reviews that have at least one attached photo.
## `country` (type: `string`):

The regional storefront to scrape. The United States is the only region available today.
## `outputRating` (type: `boolean`):

Include the star rating (1 to 5).
## `outputContent` (type: `boolean`):

Include the review body text.
## `outputTimestamp` (type: `boolean`):

Include the ISO timestamp of when the review was posted.
## `outputAuthorHandle` (type: `boolean`):

Include the reviewer's TikTok handle (privacy-masked by TikTok for most reviews).
## `outputAuthorName` (type: `boolean`):

Include the reviewer's display name when different from the handle.
## `outputAuthorAvatar` (type: `boolean`):

Include the URL of the reviewer's profile photo.
## `outputAuthorVerified` (type: `boolean`):

Include whether the review is from a verified purchase.
## `outputAuthorCountry` (type: `boolean`):

Include the country the review was posted from.
## `outputImages` (type: `boolean`):

Include the array of photo URLs attached to the review.
## `outputSkuId` (type: `boolean`):

Include the ID of the specific variant/SKU the reviewer bought.
## `outputProductTitle` (type: `boolean`):

Include the title of the product the review is for.
## `outputProductMainImage` (type: `boolean`):

Include the URL of the product's main image.
## `outputProductUrl` (type: `boolean`):

Include the canonical TikTok Shop URL of the product.
## `outputSourceShopId` (type: `boolean`):

Include the ID of the shop selling the product.
## `outputInputUrl` (type: `boolean`):

Include the URL or input the row was discovered from (the product URL, shop URL, or synthesized product URL for raw IDs).

## Actor input object example

```json
{
  "urls": [
    "https://www.tiktok.com/shop/pdp/_/1731349100249977343"
  ],
  "productIds": [],
  "maxReviewsPerTarget": 30,
  "maxProductsPerShop": 5,
  "sortBy": "newest",
  "starRating": 0,
  "withPhotosOnly": false,
  "country": "US",
  "outputRating": true,
  "outputContent": true,
  "outputTimestamp": true,
  "outputAuthorHandle": true,
  "outputAuthorName": true,
  "outputAuthorAvatar": true,
  "outputAuthorVerified": true,
  "outputAuthorCountry": true,
  "outputImages": true,
  "outputSkuId": true,
  "outputProductTitle": true,
  "outputProductMainImage": true,
  "outputProductUrl": true,
  "outputSourceShopId": true,
  "outputInputUrl": true
}
````

# Actor output Schema

## `reviews` (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 = {
    "urls": [
        "https://www.tiktok.com/shop/pdp/_/1731349100249977343"
    ],
    "productIds": [],
    "maxReviewsPerTarget": 30,
    "maxProductsPerShop": 5,
    "sortBy": "newest",
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/tiktok-shop-reviews-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 = {
    "urls": ["https://www.tiktok.com/shop/pdp/_/1731349100249977343"],
    "productIds": [],
    "maxReviewsPerTarget": 30,
    "maxProductsPerShop": 5,
    "sortBy": "newest",
    "country": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/tiktok-shop-reviews-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 '{
  "urls": [
    "https://www.tiktok.com/shop/pdp/_/1731349100249977343"
  ],
  "productIds": [],
  "maxReviewsPerTarget": 30,
  "maxProductsPerShop": 5,
  "sortBy": "newest",
  "country": "US"
}' |
apify call lurkapi/tiktok-shop-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Reviews Scraper",
        "description": "Scrape TikTok Shop product reviews by product URL, product ID, or shop URL. Returns review text, rating, date, author, photos, and product context per row.",
        "version": "0.0",
        "x-build-id": "GdBc6RASpdfSsAMfx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~tiktok-shop-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-tiktok-shop-reviews-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/lurkapi~tiktok-shop-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-tiktok-shop-reviews-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/lurkapi~tiktok-shop-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-tiktok-shop-reviews-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": {
                    "urls": {
                        "title": "Product or shop URLs",
                        "type": "array",
                        "description": "Scrape reviews from product URLs (tiktok.com/shop/pdp/...) or shop URLs (tiktok.com/shop/s/SHOP_ID). Mix both; each is auto-detected. @username links aren't supported; use a URL with the numeric shop ID.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productIds": {
                        "title": "Product IDs",
                        "type": "array",
                        "description": "Scrape reviews for specific products by ID. The product ID is the 18-19 digit number in any product URL (e.g. 1731349100249977343). One per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerTarget": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on reviews returned per product. No upper limit; TikTok itself stops serving the public feed somewhere around 2,000-2,400 reviews per product.",
                        "default": 50
                    },
                    "maxProductsPerShop": {
                        "title": "Max products per shop",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "When a shop URL is provided, this caps how many of the shop's products will have their reviews scraped. Product URL inputs ignore this cap.",
                        "default": 5
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "recommended"
                        ],
                        "type": "string",
                        "description": "How to order the reviews returned. 'newest' picks the most recent first; 'recommended' uses TikTok's relevance ranking (tends to surface higher-quality reviews with photos first).",
                        "default": "newest"
                    },
                    "starRating": {
                        "title": "Star rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Limit reviews to one specific star rating (1 to 5). Use 0 (default) to return reviews of any rating.",
                        "default": 0
                    },
                    "withPhotosOnly": {
                        "title": "Only reviews with photos",
                        "type": "boolean",
                        "description": "Return only reviews that have at least one attached photo.",
                        "default": false
                    },
                    "country": {
                        "title": "TikTok Shop region",
                        "enum": [
                            "US"
                        ],
                        "type": "string",
                        "description": "The regional storefront to scrape. The United States is the only region available today.",
                        "default": "US"
                    },
                    "outputRating": {
                        "title": "Output: rating",
                        "type": "boolean",
                        "description": "Include the star rating (1 to 5).",
                        "default": true
                    },
                    "outputContent": {
                        "title": "Output: review text",
                        "type": "boolean",
                        "description": "Include the review body text.",
                        "default": true
                    },
                    "outputTimestamp": {
                        "title": "Output: review date",
                        "type": "boolean",
                        "description": "Include the ISO timestamp of when the review was posted.",
                        "default": true
                    },
                    "outputAuthorHandle": {
                        "title": "Output: author handle",
                        "type": "boolean",
                        "description": "Include the reviewer's TikTok handle (privacy-masked by TikTok for most reviews).",
                        "default": true
                    },
                    "outputAuthorName": {
                        "title": "Output: author display name",
                        "type": "boolean",
                        "description": "Include the reviewer's display name when different from the handle.",
                        "default": true
                    },
                    "outputAuthorAvatar": {
                        "title": "Output: author avatar",
                        "type": "boolean",
                        "description": "Include the URL of the reviewer's profile photo.",
                        "default": true
                    },
                    "outputAuthorVerified": {
                        "title": "Output: verified-purchase flag",
                        "type": "boolean",
                        "description": "Include whether the review is from a verified purchase.",
                        "default": true
                    },
                    "outputAuthorCountry": {
                        "title": "Output: author country",
                        "type": "boolean",
                        "description": "Include the country the review was posted from.",
                        "default": true
                    },
                    "outputImages": {
                        "title": "Output: review photos",
                        "type": "boolean",
                        "description": "Include the array of photo URLs attached to the review.",
                        "default": true
                    },
                    "outputSkuId": {
                        "title": "Output: SKU ID",
                        "type": "boolean",
                        "description": "Include the ID of the specific variant/SKU the reviewer bought.",
                        "default": true
                    },
                    "outputProductTitle": {
                        "title": "Output: product title",
                        "type": "boolean",
                        "description": "Include the title of the product the review is for.",
                        "default": true
                    },
                    "outputProductMainImage": {
                        "title": "Output: product main image",
                        "type": "boolean",
                        "description": "Include the URL of the product's main image.",
                        "default": true
                    },
                    "outputProductUrl": {
                        "title": "Output: product URL",
                        "type": "boolean",
                        "description": "Include the canonical TikTok Shop URL of the product.",
                        "default": true
                    },
                    "outputSourceShopId": {
                        "title": "Output: shop ID",
                        "type": "boolean",
                        "description": "Include the ID of the shop selling the product.",
                        "default": true
                    },
                    "outputInputUrl": {
                        "title": "Output: source input URL",
                        "type": "boolean",
                        "description": "Include the URL or input the row was discovered from (the product URL, shop URL, or synthesized product URL for raw IDs).",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
