# TikTok Trends Scraper (`fetch_cat/tiktok-trends-scraper`) Actor

Track public TikTok Explore topics, hashtag pages, sounds, and videos for social media research.

- **URL**: https://apify.com/fetch\_cat/tiktok-trends-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.15 / 1,000 item extracteds

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

Track and export public TikTok Explore topics, hashtag pages, sounds, and video trend records by URL, keyword, country, language, and trend type.

Use this Actor to collect TikTok trend data for social media research, content planning, ecommerce monitoring, creator strategy, campaign tracking, and recurring trend dashboards. Results can be downloaded as CSV, JSON, Excel, XML, RSS, or used through the Apify Dataset API.

### At a glance

- **Trend URL input**: Start from TikTok Discover, hashtag pages, sound pages, or public video URLs.
- **Keyword to hashtag workflow**: Enter keywords such as `travel` or `skincare` and the Actor converts them into TikTok hashtag URLs.
- **Trend records**: Export trend type, rank, title, hashtag, description, video URL, author, sound title, public counts, region label, source URL, and timestamp.
- **Monitoring ready**: Run the same trend inputs on a schedule to build daily or weekly snapshots.
- **API export**: Send TikTok trend rows to spreadsheets, dashboards, content calendars, BI tools, or AI agents.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Archive daily TikTok trend snapshots](https://apify.com/fetch_cat/tiktok-trends-scraper/examples/tiktok-daily-trend-archive)**
- **[Discover viral topic themes on TikTok](https://apify.com/fetch_cat/tiktok-trends-scraper/examples/tiktok-viral-topic-discovery)**
- **[Find TikTok content ideas for local businesses](https://apify.com/fetch_cat/tiktok-trends-scraper/examples/tiktok-local-business-ideas)**
- **[Track seasonal retail trends on TikTok](https://apify.com/fetch_cat/tiktok-trends-scraper/examples/tiktok-seasonal-retail-trends)**
- **[Run a weekly TikTok brand planning snapshot](https://apify.com/fetch_cat/tiktok-trends-scraper/examples/tiktok-weekly-brand-planning)**
- **[Create a TikTok trends export for Google Sheets](https://apify.com/fetch_cat/tiktok-trends-scraper/examples/tiktok-google-sheets-report)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/tiktok-trends-scraper/examples)** (50 examples)

### What can it do?

TikTok Trends Scraper turns public TikTok trend pages and keyword-derived hashtag pages into structured dataset rows.

- **Collect Discover topics**: Use `https://www.tiktok.com/discover` for public Explore topic rows.
- **Track hashtag pages**: Enter hashtag keywords or TikTok `/tag/` URLs.
- **Inspect sound and video URLs**: Add public sound or video URLs when you need source-linked trend records.
- **Label by region and language**: Store your target country and preferred language with each row.
- **Export snapshots**: Use Apify schedules, API calls, webhooks, and integrations for recurring trend monitoring.

### Common workflows

- **Content planning**: Find recurring TikTok topics, hashtags, sounds, and public video examples.
- **Trend dashboards**: Build daily or weekly trend snapshots by region, keyword, or source URL.
- **Ecommerce monitoring**: Track public product, lifestyle, seasonal, or category themes.
- **Campaign research**: Watch hashtag pages around launches, events, creators, or communities.
- **Creator strategy**: Identify content patterns, sound topics, and video examples for ideation.
- **Market research**: Compare public TikTok trend rows across country labels and keyword groups.

### What data can you extract?

The Actor returns one dataset row per public TikTok trend item.

| Field | Description |
| --- | --- |
| `rank` | Rank within the extracted trend list |
| `trendType` | Discover, hashtag, sound, or video |
| `title` | Trend topic, hashtag page title, sound title, or video title |
| `hashtag` | Hashtag when available or derived from the topic |
| `description` | Public trend or topic description when available |
| `videoUrl` | Public TikTok video URL when the input is a video |
| `authorUsername` | Public author username when exposed |
| `soundTitle` | Sound title for sound URLs |
| `viewCount` | Optional public view count |
| `likeCount` | Optional public like count |
| `commentCount` | Optional public comment count |
| `shareCount` | Optional public share count |
| `region` | Country or region label supplied in the input |
| `keywordOrUrl` | Input keyword-derived URL or original URL |
| `sourceUrl` | TikTok URL used for the record |
| `scrapedAt` | ISO timestamp for the run |

### Pricing

The Actor uses pay-per-event pricing, so cost is tied to the run and the number of saved trend rows.

| Event | Price | Charged when |
| --- | --- | --- |
| Run start | `$0.005` per run | Once when the Actor starts. |
| Trend item | BRONZE `$0.00025587` per saved trend row | Each TikTok trend item saved to the dataset. This is about `$0.25587` per 1,000 saved rows on BRONZE, with lower per-result prices on higher Apify plans. |

Use a low `maxItems` value for the first run, review the dataset, and then scale up. Exact live pricing is shown on the Apify Actor page before you start a run.

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| TikTok URLs | `startUrls` | Public TikTok Discover, tag, music, or video URLs to inspect. | `[{"url":"https://www.tiktok.com/discover"}]` |
| Hashtag keywords | `keywords` | Keywords that should be converted into TikTok hashtag URLs. | `["travel", "skincare"]` |
| Default trend type | `trendType` | Fallback type when a URL does not clearly identify its type. | `discover` |
| Country / region code | `country` | Region label stored with each result. | `US` |
| Language code | `language` | Preferred public page language. | `en` |
| Maximum trend items | `maxItems` | Cap saved rows and spend. | `20` |
| Proxy configuration | `proxyConfiguration` | Optional Apify Proxy settings for public TikTok pages. | `{"useApifyProxy":true}` |

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.tiktok.com/discover" }
  ],
  "keywords": ["travel", "skincare"],
  "country": "US",
  "language": "en",
  "trendType": "discover",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

### Example output

```json
{
  "rank": 1,
  "trendType": "hashtag",
  "title": "skincare",
  "hashtag": "skincare",
  "description": "Public TikTok hashtag topic",
  "videoUrl": "https://www.tiktok.com/@creator/video/...",
  "authorUsername": "creator",
  "soundTitle": null,
  "viewCount": 1234567,
  "likeCount": 12345,
  "commentCount": 123,
  "shareCount": 45,
  "region": "US",
  "keywordOrUrl": "skincare",
  "sourceUrl": "https://www.tiktok.com/tag/skincare",
  "scrapedAt": "2026-06-23T14:30:00.000Z"
}
```

### How to run it

1. Open the Actor on Apify.
2. Keep the Discover URL or add public TikTok tag, music, or video URLs.
3. Add optional hashtag keywords.
4. Set country, language, trend type, and `maxItems`.
5. Choose proxy settings if needed.
6. Start the run and export the dataset.

### Search tips

- **Use keyword groups**: Compare related topics such as `travel`, `skincare`, and `fitness`.
- **Keep snapshots small**: Use `maxItems: 20` while testing trend inputs.
- **Schedule the same inputs**: Recurring runs are useful for trend movement over time.
- **Label regions consistently**: Use the same `country` value for comparable trend snapshots.
- **Use URLs for precision**: Paste exact TikTok tag, sound, or video URLs when a keyword is ambiguous.

### Limits and caveats

- The Actor extracts publicly visible TikTok pages only.
- It is not a replacement for private TikTok analytics, creator dashboards, or ad account reporting.
- TikTok may localize, cache, limit, or block public trend pages.
- Some count fields are empty when TikTok does not expose them on the public page.

### Integrations

You can connect TikTok trend data to downstream tools:

- Export CSV or Excel to content calendars and trend trackers.
- Load JSON rows into dashboards for scheduled trend snapshots.
- Trigger webhooks after daily or weekly monitoring runs.
- Send trend rows to AI tools for clustering or content ideation.
- Combine trends with TikTok hashtag, profile, video, and ads datasets.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/tiktok-trends-scraper').call({
  startUrls: [{ url: 'https://www.tiktok.com/discover' }],
  keywords: ['travel', 'skincare'],
  country: 'US',
  maxItems: 20
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/tiktok-trends-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.tiktok.com/discover'}],
    'keywords': ['travel', 'skincare'],
    'country': 'US',
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~tiktok-trends-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.tiktok.com/discover"}],"keywords":["travel","skincare"],"country":"US","maxItems":20}'
```

### MCP and AI agents

This Actor can be used through the official Apify MCP server at `https://mcp.apify.com`.

For a focused single-Actor tool setup, use:

```text
https://mcp.apify.com?tools=fetch_cat/tiktok-trends-scraper
```

Use the same JSON keys shown in the input configuration table, such as `startUrls`, `keywords`, `trendType`, `country`, `language`, and `maxItems`.

### FAQ

#### Can I use this as a TikTok trends API?

Yes. You can run the Actor through the Apify API and read results from the Dataset API.

#### Is this a replacement for TikTok analytics?

No. It extracts public trend pages and public metadata only.

#### Can I schedule daily trend checks?

Yes. Use Apify schedules with the same URLs, keywords, country, and `maxItems` values.

#### Why did I get fewer rows than requested?

TikTok may expose fewer public items for a page, keyword, region, or connection at the time of the run.

### Related scrapers

- [TikTok Hashtag Scraper](https://apify.com/fetch_cat/tiktok-hashtag-scraper)
- [TikTok Profile Scraper](https://apify.com/fetch_cat/tiktok-profile-scraper)
- [TikTok Video Scraper](https://apify.com/fetch_cat/tiktok-video-scraper)
- [TikTok Ads Library Scraper](https://apify.com/fetch_cat/tiktok-ads-library-scraper)
- [YouTube Shorts Scraper](https://apify.com/fetch_cat/youtube-shorts-scraper)

### Changelog

#### 0.1

- Initial public release with Discover, hashtag keyword, tag URL, sound URL, video URL, region, language, proxy, and maximum-result controls.

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

# Actor input Schema

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

Public TikTok URLs to inspect. Use https://www.tiktok.com/discover for ranked Explore topics, or add public /tag/, /music/, and /video/ URLs.

## `keywords` (type: `array`):

Optional hashtag keywords. For example, travel becomes https://www.tiktok.com/tag/travel.

## `trendType` (type: `string`):

Default type used when a URL does not clearly identify its type. URL paths such as /tag/ and /music/ are detected automatically.

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

Optional ISO country code stored with each result, such as US, GB, DE, or FR.

## `language` (type: `string`):

Preferred page language for TikTok public pages.

## `maxItems` (type: `integer`):

Maximum number of trend records to save.

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

Optional proxy settings. Datacenter proxy is usually enough for public discovery pages; use residential only if TikTok blocks your region.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tiktok.com/discover"
    }
  ],
  "keywords": [
    "travel",
    "skincare"
  ],
  "trendType": "discover",
  "country": "US",
  "language": "en",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.tiktok.com/discover"
        }
    ],
    "keywords": [
        "travel",
        "skincare"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/tiktok-trends-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.tiktok.com/discover" }],
    "keywords": [
        "travel",
        "skincare",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/tiktok-trends-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.tiktok.com/discover"
    }
  ],
  "keywords": [
    "travel",
    "skincare"
  ]
}' |
apify call fetch_cat/tiktok-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Trends Scraper",
        "description": "Track public TikTok Explore topics, hashtag pages, sounds, and videos for social media research.",
        "version": "0.1",
        "x-build-id": "Z7fDoF2E7npeLipDs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~tiktok-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-tiktok-trends-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/fetch_cat~tiktok-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-tiktok-trends-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/fetch_cat~tiktok-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-tiktok-trends-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": {
                    "startUrls": {
                        "title": "TikTok URLs",
                        "type": "array",
                        "description": "Public TikTok URLs to inspect. Use https://www.tiktok.com/discover for ranked Explore topics, or add public /tag/, /music/, and /video/ URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Hashtag keywords",
                        "type": "array",
                        "description": "Optional hashtag keywords. For example, travel becomes https://www.tiktok.com/tag/travel.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "trendType": {
                        "title": "Default trend type",
                        "enum": [
                            "discover",
                            "hashtag",
                            "sound",
                            "video"
                        ],
                        "type": "string",
                        "description": "Default type used when a URL does not clearly identify its type. URL paths such as /tag/ and /music/ are detected automatically.",
                        "default": "discover"
                    },
                    "country": {
                        "title": "Country / region code",
                        "type": "string",
                        "description": "Optional ISO country code stored with each result, such as US, GB, DE, or FR.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language code",
                        "type": "string",
                        "description": "Preferred page language for TikTok public pages.",
                        "default": "en"
                    },
                    "maxItems": {
                        "title": "Maximum trend items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of trend records to save.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Datacenter proxy is usually enough for public discovery pages; use residential only if TikTok blocks your region.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
