# TikTok Shop Product Scraper (`futurizerush/tiktok-shop-product-scraper`) Actor

Extract product details from TikTok Shop in clean, ready-to-use datasets. Supports product pages and category browsing in the United States. No login or account required. (Beta)

- **URL**: https://apify.com/futurizerush/tiktok-shop-product-scraper.md
- **Developed by:** [Rush](https://apify.com/futurizerush) (community)
- **Categories:** AI, Agents, E-commerce
- **Stats:** 3 total users, 1 monthly users, 53.5% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## TikTok Shop Product Scraper

Pull product details from TikTok Shop in a clean, ready-to-use dataset. Works with direct product pages and category browsing on the United States storefront. **No login. No account. No cookies required.**

---

### What you can do

- Collect product details from TikTok Shop product pages — the most direct path
- Browse a category page and collect the products it lists (a couple of dozen products per page; some individual products may need a re-run)
- Get titles, prices, ratings, reviews, units sold, stock, images, variants, and seller information
- Receive a short run report alongside each run, summarising what was collected and what didn't load
- Use it from the Apify Console, the Apify API, or via integrations such as Make and n8n

> Both modes work. **Product URLs** are the most direct path; **category URLs** expand into the products listed on the page and fetch each one. Some individual products in a category batch may not return data on every run — see *Why some URLs may not load* below.

---

### Input

Enter at least one **product URL** or **category URL**. Both formats below are supported.

| Field | Type | Default | What it does |
|---|---|---|---|
| 🔗 Product or Category URLs | List | (required) | TikTok Shop links to collect from. Accepts product pages and category pages on the United States storefront. Up to 50 URLs per run. |
| 🎯 Maximum products per input | Number | 50 | Cap on products collected per category URL (10–500). Direct product URLs always count as 1 regardless of this setting. |

#### Supported URL formats

Two kinds of TikTok Shop links work — copy whichever your browser shows:

- A **product page**, for example `https://shop.tiktok.com/us/pdp/r4-sdhc-2026-gold-pro-card-com-with-usb-adapter-dual-core/1732203653508141173`
- A **category page**, for example `https://shop.tiktok.com/us/c/phones-electronics/601739`

#### Example input

```json
{
    "productUrls": [
        "https://shop.tiktok.com/us/pdp/r4-sdhc-2026-gold-pro-card-com-with-usb-adapter-dual-core/1732203653508141173",
        "https://shop.tiktok.com/us/c/phones-electronics/601739"
    ],
    "maxProductsPerInput": 50
}
````

> Tip: paste the URL directly from your browser's address bar. Full URLs
> with the product-name part included tend to load more reliably than
> shortened links.

***

### Output

**Every product is one row.** Direct product URLs map to one row each; category URLs are expanded into rows for the products discovered on that page (capped by **🎯 Maximum products per input**). Two URLs that point at the same product are merged into a single row to keep the dataset deduplicated — a log line surfaces the skipped URL when this happens. Both successful and failed attempts land in the dataset, so the run is fully traceable. Filter by `status === 'success'` to keep only the collected products.

Each row includes:

- Status: `status` (`'success'` or `'failed'`), `attemptedUrl`, `error` (filled on failure rows)
- Product identity: `productId`, `title`, `description`, `url`, `region`
- Pricing: `priceCurrent`, `priceOriginal`, `discountPercent`, `currency`
- Reception: `ratingAverage`, `reviewCount`, `unitsSold`, `stockQuantity`
- Seller: `sellerId`, `sellerName`, `sellerUrl`, `sellerRating`
- Catalog: `categoryBreadcrumb`
- Media: `firstImage` (the lead product photo, also appears as `images[0]`), `images`, `videos`
- Variants: `variants` with per-variant pricing and properties (such as colour or size)
- Timestamp & version: `extractedAt` (when this row was collected) and `schemaVersion` (the row layout version, useful when comparing datasets collected on different days)

#### Example output

**Success row** — TikTok served the product page and we collected the details:

```json
{
    "status": "success",
    "attemptedUrl": "https://shop.tiktok.com/us/pdp/playstation-dualsense-wireless-controller-starlight-blue-motion-control-bluetooth-connectivity/1729452403652203222",
    "error": null,
    "productId": "1729452403652203222",
    "title": "PlayStation DualSense Wireless Controller — Starlight Blue",
    "description": "Signature comfort: Take control with an evolved, two-tone design...",
    "url": "https://shop.tiktok.com/us/pdp/playstation-dualsense-wireless-controller-starlight-blue-motion-control-bluetooth-connectivity/1729452403652203222",
    "region": "us",
    "priceCurrent": 79.49,
    "priceOriginal": 79.49,
    "discountPercent": 0,
    "currency": "USD",
    "ratingAverage": 4.9,
    "reviewCount": 455,
    "unitsSold": 3553,
    "stockQuantity": 1445,
    "sellerId": "7495122322888035030",
    "sellerName": "Newegg, Inc.",
    "sellerUrl": "https://shop.tiktok.com/us/store/x/7495122322888035030",
    "sellerRating": 4.6,
    "categoryBreadcrumb": ["Phones & Electronics", "Gaming & Consoles", "Console Accessories"],
    "firstImage": "https://p16-oec-general-useast5.ttcdn-us.com/...",
    "images": ["https://p16-oec-general-useast5.ttcdn-us.com/..."],
    "videos": [],
    "variants": [
        {
            "skuId": "1729452403652268758",
            "properties": [{"name": "Color", "value": "Starlight Blue"}],
            "priceCurrent": 79.49,
            "availableQuantity": 1445,
            "imageUrl": null,
            "isActive": true
        }
    ],
    "extractedAt": "2026-05-03T05:43:44.345Z",
    "schemaVersion": "2026-05-03"
}
```

**Failure row** — the URL was attempted but did not yield a product. The `error` field tells you why so you can decide whether re-running helps:

```json
{
    "status": "failed",
    "attemptedUrl": "https://shop.tiktok.com/us/pdp/portable-projector-stand-for-home-office-desktop-floor-use/1731050925280301480",
    "error": "This product was not available on this attempt — re-running usually picks it up.",
    "productId": "1731050925280301480",
    "title": null,
    "description": null,
    "url": "https://shop.tiktok.com/us/pdp/portable-projector-stand-for-home-office-desktop-floor-use/1731050925280301480",
    "region": "us",
    "priceCurrent": null,
    "priceOriginal": null,
    "discountPercent": 0,
    "currency": "USD",
    "ratingAverage": null,
    "reviewCount": null,
    "unitsSold": null,
    "stockQuantity": null,
    "sellerId": null,
    "sellerName": null,
    "sellerUrl": null,
    "sellerRating": null,
    "categoryBreadcrumb": [],
    "firstImage": null,
    "images": [],
    "videos": [],
    "variants": [],
    "extractedAt": "2026-05-03T05:43:44.345Z",
    "schemaVersion": "2026-05-03"
}
```

A short run report is also saved with the run, summarising how many products were requested, how many were collected, and how many didn't load. The report groups any unsuccessful items by reason so you can see at a glance whether the issue was a temporary one (worth re-running) or something else. When most of a run hits the same transient TikTok throttle wave, the report's `note` field surfaces a one-line heads-up so you know it's an upstream blip rather than your input.

> Numeric fields such as `ratingAverage`, `reviewCount`, `unitsSold`, and `stockQuantity` may be `null` when TikTok's page does not include the value. The scraper does not invent zeros where the source is silent — for example, a product with no reviews has `ratingAverage: null` rather than `0`.

> Multi-variant products (e.g. phone cases offered in many colours) include a per-variant `imageUrl` whenever the seller has uploaded swatch images. Single-variant products typically have `imageUrl: null` because there is no swatch to choose from.

> The `videos` array, when populated, contains the seller's posted video URLs straight from TikTok. These URLs are short-lived and may not work outside TikTok's own player — they are best treated as references to the video, not always-playable links.

***

### Why some URLs may not load

Some URLs in any batch may not return data. The most common reasons:

- **The product is no longer listed.** Sellers sometimes remove products, restrict them by region, or take stores offline. The URL still resolves but the product is gone. The `error` field reads *no longer available* and re-running will not help.
- **TikTok is briefly busy.** Some pages don't load on the first try. The scraper retries automatically; if every attempt fails, the `error` field reads *not available on this attempt* — usually clears up on the next run.
- **Some category URLs are restricted for anonymous browsing.** TikTok withholds products on a subset of category URLs even though the page itself loads. The actor's verified set covers the major TikTok Shop categories; the rest return an *appears to be restricted for anonymous browsing* error and re-running will not help. The error message names the verified-working categories whenever you hit a restricted one, so you can switch to one of those or to direct product URLs (which are not gated by category restrictions and work even for products inside restricted categories).
- **Category pages return a snapshot.** A category URL returns the products TikTok lists on that page at the moment of collection; the list updates as TikTok's catalog changes. Individual products within the snapshot may still hit the *not available on this attempt* condition above and fall to the failure-row path.

For best results, paste full URLs from the browser address bar, run smaller batches when collecting many URLs, and re-run anything that didn't load.

***

### How it works

The scraper visits each URL you provide, reads the public product information that TikTok shows to ordinary visitors, and writes one row per attempted URL to the dataset (success rows carry product details; failed rows carry an `error` reason). Category URLs are expanded into the products listed on them (capped by **🎯 Maximum products per input**). Only public storefront pages are accessed — there is no login required and no risk to any TikTok account.

***

### FAQ

**Do I need a TikTok account?**
No. The scraper only reads pages that any visitor can open in a browser. Your Apify account is the only credential involved.

**Why does my run sometimes return fewer products than I requested?**
Every URL produces a dataset row, so nothing is silently dropped. Filter by `status === 'success'` for the collected products; rows with `status: "failed"` carry an `error` field explaining why. See *Why some URLs may not load* above for the common reasons.

**What if most of my run failed at once?**
Sometimes TikTok is briefly unavailable for many URLs in a single run. When the run report's `note` field carries a one-line heads-up, that's the signal it's an upstream blip rather than your input. Waiting 10–30 minutes and re-running usually clears it. Direct product URLs are simpler than category URLs — they go directly to one page rather than discovering and then fetching the products inside.

**Why does a category URL return zero products?**
TikTok restricts a subset of category URLs for anonymous browsing. The actor's verified set covers the major shopping categories; whenever you hit a restricted one, the failure row's `error` field in the dataset names the verified-working categories so you can switch. Re-running a restricted category URL will not help. Direct product URLs to the same products still work — including for products inside restricted categories — so the simplest workaround is to feed the actor product page URLs.

**Are there URL formats that work better than others?**
Yes. URLs copied directly from your browser's address bar — the ones that include the full product name — are the safest bet. Shortened links may not always load.

**Can I scrape regions other than the United States?**
This release supports the US storefront only. Non-US URLs are rejected with a clear message.

**Can I use this for Seller Center data, orders, or my shop dashboard?**
No. Anything that requires login is outside the scope of this actor. Only public storefront pages are supported.

**What if TikTok changes the page structure?**
TikTok occasionally adjusts its page layout. When that happens, you may see some fields missing from the output until the scraper is updated. The `extractedAt` timestamp on each row helps you compare collections taken at different times.

***

### Disclaimer

> **Beta release.** Some bugs and gaps may remain. **Run a small batch first** to confirm the output meets your needs before scaling up. TikTok Shop adjusts its page layout from time to time — fields may shift or disappear without warning until the scraper catches up.

> **For learning and research use only.** Please use the data responsibly: respect TikTok's Terms of Service, applicable local laws, and the rights of sellers and shoppers featured in the data. Do not use it for harassment, deception, or any purpose that harms third parties.

> **Found a problem?** Open an issue on this actor's Apify page and we'll look into it.

This actor only retrieves publicly accessible information that TikTok shows to ordinary visitors. The scraper is provided as-is, with no guarantee of completeness, accuracy, timeliness, or fitness for any particular purpose. TikTok and TikTok Shop are trademarks of their respective owners and are not affiliated with this actor.

***

### Like this actor?

Sign up for Apify through this referral link to support continued development: <https://apify.com/futurizerush?fpr=rush>

***

OpenClaw, Claude Code, Gemini, Antigravity, Codex, ChatGPT

# Actor input Schema

## `productUrls` (type: `array`):

TikTok Shop links to collect from on the United States storefront. Tip: paste the full URL from your browser's address bar. Both product pages and category pages work; category pages expand into the products they list. Up to 50 URLs per run. Note: TikTok restricts a subset of category URLs for anonymous browsing — when that happens, the failure row's error field in the dataset names the verified-working categories. Direct product URLs are not gated by category restrictions, so they are the simplest workaround.

## `maxProductsPerInput` (type: `integer`):

Cap on the number of products collected from each category URL. Direct product URLs always count as 1 regardless of this setting.

## Actor input object example

```json
{
  "productUrls": [
    "https://shop.tiktok.com/us/pdp/r4-sdhc-2026-gold-pro-card-com-with-usb-adapter-dual-core/1732203653508141173"
  ],
  "maxProductsPerInput": 50
}
```

# Actor output Schema

## `products` (type: `string`):

All product rows collected in this run. Direct product URLs map to one row each; category URLs are expanded into rows for their discovered products. Two URLs that point at the same product are merged into a single row. Filter status='success' for the products that were successfully collected.

## `runSummary` (type: `string`):

Run-level summary: products requested, collected, and failed (grouped by reason). Includes a `note` field that carries a one-line heads-up when most URLs in a single run could not be reached — usually a brief TikTok-side condition that clears within a few minutes.

# 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 = {
    "productUrls": [
        "https://shop.tiktok.com/us/pdp/r4-sdhc-2026-gold-pro-card-com-with-usb-adapter-dual-core/1732203653508141173"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("futurizerush/tiktok-shop-product-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 = { "productUrls": ["https://shop.tiktok.com/us/pdp/r4-sdhc-2026-gold-pro-card-com-with-usb-adapter-dual-core/1732203653508141173"] }

# Run the Actor and wait for it to finish
run = client.actor("futurizerush/tiktok-shop-product-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 '{
  "productUrls": [
    "https://shop.tiktok.com/us/pdp/r4-sdhc-2026-gold-pro-card-com-with-usb-adapter-dual-core/1732203653508141173"
  ]
}' |
apify call futurizerush/tiktok-shop-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Product Scraper",
        "description": "Extract product details from TikTok Shop in clean, ready-to-use datasets. Supports product pages and category browsing in the United States. No login or account required. (Beta)",
        "version": "0.0",
        "x-build-id": "6ZKk6kjmvAQgccEy5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/futurizerush~tiktok-shop-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-futurizerush-tiktok-shop-product-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/futurizerush~tiktok-shop-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-futurizerush-tiktok-shop-product-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/futurizerush~tiktok-shop-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-futurizerush-tiktok-shop-product-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",
                "required": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "🔗 Product or Category URLs",
                        "minItems": 1,
                        "maxItems": 50,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "TikTok Shop links to collect from on the United States storefront. Tip: paste the full URL from your browser's address bar. Both product pages and category pages work; category pages expand into the products they list. Up to 50 URLs per run. Note: TikTok restricts a subset of category URLs for anonymous browsing — when that happens, the failure row's error field in the dataset names the verified-working categories. Direct product URLs are not gated by category restrictions, so they are the simplest workaround.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProductsPerInput": {
                        "title": "🎯 Maximum products per input",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on the number of products collected from each category URL. Direct product URLs always count as 1 regardless of this setting.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
