# TikTok Hashtag Trends Scraper & Breakout Radar | $2/1K (`webdata_labs/tiktok-hashtag-trends-scraper`) Actor

Discover trending TikTok hashtags by country, industry, and period. Export views, posts, momentum, popularity curves, and top creators. $2 per 1,000 rows; platform usage included.

- **URL**: https://apify.com/webdata\_labs/tiktok-hashtag-trends-scraper.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 tiktok hashtag trends

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Hashtag Trends Scraper & Breakout Radar turns public [TikTok Creative Center](https://ads.tiktok.com/business/creativecenter/inspiration/popular/hashtag/pc/en) trend charts into structured, analysis-ready data. Discover hashtags gaining momentum, compare markets and time windows, scan industry-specific charts, and automate recurring trend research without manually checking dozens of pages.

Use it as a **TikTok hashtag trends API**, a weekly discovery workflow, or a data source for content planning, social listening, market research, and creative intelligence.

### What does TikTok Hashtag Trends Scraper do?

The Actor collects public hashtag trend snapshots by country, lookback period, and industry slice. It enriches TikTok's raw chart data with normalized URLs and derived signals such as **momentum**, **volatility**, and **trend stage**, then saves one clean dataset row per unique hashtag, country, and period.

It is designed to answer questions such as:

- Which hashtags are breaking out in the US this week?
- Which trends are rising in one market but not another?
- What hashtags are appearing inside industry charts but not in the overall chart?
- Is a hashtag still accelerating, stable, or already fading?
- Which public creators are associated with a trending hashtag?

This Actor does not scrape private TikTok data, search results, individual videos, or the complete internal TikTok ranking. It structures the public trend data TikTok currently exposes through Creative Center.

### Why use this TikTok hashtag trends API?

TikTok Creative Center is useful for manual research, but comparing multiple countries, periods, and industry categories quickly becomes repetitive. This Actor automates that work and produces data that can be filtered, joined, scored, stored, and monitored over time.

#### Find trends before they become obvious

The overall chart is only one view of the market. With **Scan industry slices** enabled, the Actor also checks public industry-specific rankings. This can reveal relevant hashtags that do not appear in the general chart.

#### Separate momentum from raw size

A hashtag with millions of views is not necessarily growing. The Actor analyzes the available popularity curve and returns:

- `momentum` — change between the first and last popularity-curve values;
- `volatility` — how much the popularity signal moves within the selected period;
- `trendStage` — a practical label: `breakout`, `rising`, `stable`, `fading`, or `unknown`.

These are deterministic research signals, not predictions or guarantees of future performance.

#### Compare countries and time windows

Run several countries and 7-, 30-, or 90-day periods together. Every result retains its country, period, industry context, source URL, and scrape timestamp, so comparisons remain auditable.

#### Build repeatable monitoring workflows

Save the input as an Apify task and run it manually, on a schedule, through the API, or from Make, Zapier, webhooks, and other Apify integrations. Store recurring snapshots in a database or BI tool to detect newly appearing, rising, or disappearing hashtags.

### Popular use cases

- **Content research:** build a weekly shortlist of rising topics for creators and social teams.
- **Market comparison:** compare hashtag momentum across countries and regional campaigns.
- **Creative strategy:** identify themes worth investigating before writing briefs or producing videos.
- **Agency reporting:** export reproducible trend snapshots for clients instead of screenshots.
- **Brand monitoring:** schedule recurring runs and alert on relevant breakout hashtags.
- **SEO and social listening:** combine hashtag signals with keyword, review, or search-trend datasets.
- **Research and data science:** analyze popularity curves, creator associations, volatility, and trend persistence.

### What TikTok hashtag data can be extracted?

| Field | Type | Description |
| --- | --- | --- |
| `hashtag` | string | Hashtag text without the `#` prefix |
| `hashtagId` | string | TikTok's public hashtag identifier |
| `country` | string | Country code used for the trend query |
| `periodDays` | number | Selected 7-, 30-, or 90-day trend window |
| `industryId` | string or null | Industry slice where the hashtag was found; `null` means the overall chart |
| `rank` | number | Rank reported for that public chart slice |
| `views` | number | Video views reported by TikTok Creative Center |
| `posts` | number | Published-post count reported by TikTok |
| `momentum` | number or null | Difference between the last and first popularity-curve values |
| `volatility` | number or null | Standard deviation of the available popularity-curve values |
| `trendStage` | string | Derived label: `breakout`, `rising`, `stable`, `fading`, or `unknown` |
| `popularityCurve` | array | Timestamped popularity values exposed for the selected period |
| `topCreators` | array | Public creator handles, names, follower counts, countries, and profile URLs when available |
| `tiktokUrl` | string | Direct TikTok hashtag URL |
| `sourceUrl` | string | Creative Center trend page corresponding to the query |
| `scrapedAt` | string | UTC timestamp of the snapshot |

Field availability depends on what TikTok exposes for a particular country, period, hashtag, and chart slice.

### How to scrape TikTok hashtag trends

1. Open the Actor's **Input** tab.
2. Add one or more country codes, for example `US`, `GB`, `DE`, `BR`, or `JP`.
3. Choose one or more trend periods: 7, 30, or 90 days.
4. Keep **Scan industry slices** enabled for broader discovery, or disable it for the overall chart only.
5. Set **Maximum results** to control the number of unique hashtag rows. Use `0` to save everything discoverable from the selected public slices.
6. Click **Save & Start**.
7. Review the dataset or download it as JSON, CSV, Excel, XML, HTML, or RSS.

For recurring monitoring, save the configuration as a task and attach an Apify schedule. Compare snapshots using `hashtagId`, `country`, `periodDays`, and `scrapedAt` rather than treating one run as a historical time series.

### Input

A simple weekly US breakout scan:

```json
{
    "countries": ["US"],
    "periods": ["7"],
    "scanAllIndustries": true,
    "maxResults": 25
}
````

A broader multi-market comparison:

```json
{
    "countries": ["US", "GB", "DE", "BR", "JP"],
    "periods": ["7", "30", "90"],
    "scanAllIndustries": true,
    "maxResults": 300
}
```

See the **Input** tab for the full configuration form.

#### Main input options

| Option | Description |
| --- | --- |
| `countries` | One or more uppercase TikTok country codes |
| `periods` | Trend windows: `7`, `30`, and/or `90` |
| `scanAllIndustries` | Scans the overall chart plus supported public industry slices |
| `maxResults` | Maximum unique rows saved across the run; `0` means no Actor-side result limit |

#### Advanced options

Most users should leave the advanced settings unchanged.

- `industryIds` scans only specific TikTok industry IDs and replaces the all-industries selection.
- `requestDelayMs` adds a pause between requests and can be increased if TikTok throttles a run.
- `requestRetries` controls retries for temporary request or TikTok API failures.

### Output

You can download the dataset in formats such as **JSON, CSV, Excel, XML, HTML, or RSS**, access it through the Apify API, or send it to another application using an integration.

Simplified result example:

```json
{
    "hashtagId": "1234567890",
    "hashtag": "exampletrend",
    "country": "US",
    "periodDays": 7,
    "industryId": "14000000000",
    "rank": 2,
    "posts": 176599,
    "views": 157573033,
    "momentum": 38,
    "volatility": 17.42,
    "trendStage": "breakout",
    "popularityCurve": [
        { "timestamp": "2026-07-11T00:00:00.000Z", "value": 45 },
        { "timestamp": "2026-07-18T00:00:00.000Z", "value": 83 }
    ],
    "topCreators": [
        {
            "username": "example_creator",
            "name": "Example Creator",
            "followers": 245000,
            "country": "US",
            "profileUrl": "https://www.tiktok.com/@example_creator"
        }
    ],
    "tiktokUrl": "https://www.tiktok.com/tag/exampletrend",
    "sourceUrl": "https://ads.tiktok.com/creative/creativeCenter/trends/hashtag?countryCode=US&period=7",
    "scrapedAt": "2026-07-18T12:00:00.000Z"
}
```

The run also writes an `OUTPUT` summary to the default key-value store with:

- final status (`SUCCEEDED` or `PARTIAL`);
- unique hashtags saved;
- raw results received;
- duplicates skipped;
- slices requested;
- per-slice errors, if any.

Summary objects and failed slices are not written as billable dataset rows.

### How much does it cost to scrape TikTok hashtag trends?

The Actor costs **$2 per 1,000 saved hashtag rows** (`$0.002` per result), with Apify platform usage included in the pay-per-event price.

Examples:

| Saved results | Actor charge |
| ---: | ---: |
| 25 | $0.05 |
| 100 | $0.20 |
| 1,000 | $2.00 |

You are charged for useful hashtag rows saved to the default dataset, not for chart requests, retries, run summaries, duplicate results, or failed slices. Your Apify plan and current Store pricing still apply; check the **Pricing** tab before a large run.

### Important coverage limitation

#### Why are there only a few results per chart?

TikTok currently returns up to **three public hashtag entries per country, period, and industry slice** to logged-out public requests. This is a TikTok-side restriction, not the Actor's `maxResults` setting.

The Actor improves useful coverage by scanning the overall ranking and multiple public industry slices, then deduplicating repeated hashtags. Consequently:

- a single overall slice may produce only three rows;
- enabling industry scanning can produce substantially more unique hashtags;
- `maxResults: 100` is a ceiling, not a promise that TikTok will expose 100 unique results;
- the Actor does not use your TikTok account, cookies, session token, or private API credentials;
- results represent a public discovery sample, not TikTok's complete internal trend database.

This architecture is intentionally session-free so saved tasks can run reliably without maintaining a fragile personal login. If TikTok changes its public endpoint or available chart depth, coverage may change.

### Tips for better trend research

- Use the 7-day period to find recent movement and the 30- or 90-day periods for context.
- Treat `rank`, `views`, and `posts` as TikTok-reported snapshot metrics, not independently audited counts.
- Filter `trendStage` to `breakout` or `rising`, then manually review relevance before using a hashtag.
- Compare the same saved task over time. One snapshot cannot tell you how long a hashtag has remained on the chart.
- Keep industry scanning on when discovery matters; turn it off when you only need the overall chart.
- Start with one country and one period while validating a workflow, then scale to more combinations.
- Use `sourceUrl` and `scrapedAt` to preserve provenance in reports and downstream pipelines.

### Automate TikTok trend monitoring with the API

Every Actor and saved task can be started through the Apify API. Open the Actor's **API** tab to copy ready-made examples for JavaScript, Python, cURL, and other clients.

A typical automation flow is:

1. Create a saved task for a market and period.
2. Schedule it weekly or daily.
3. Send completed datasets to a webhook, cloud storage, Make, Zapier, or a database.
4. Compare the new dataset with the previous snapshot by hashtag and country.
5. Alert only when a hashtag is new, has become `breakout`, or crosses your own views/posts threshold.

### FAQ

#### Is this an official TikTok API?

No. This Actor structures public data available through TikTok Creative Center. It is not affiliated with, endorsed by, or operated by TikTok.

#### Do I need a TikTok login, cookie, or token?

No. The Actor uses public, logged-out trend data. Do not paste TikTok credentials into the input.

#### Does `maxResults` guarantee that number of rows?

No. It is the maximum number the Actor will save. The actual count depends on the countries, periods, industry slices, duplicate hashtags, and data TikTok makes publicly available.

#### Why does the same hashtag appear more than once?

The Actor deduplicates within each country and period. The same hashtag can legitimately appear as a separate row for another country or period because its rank, curve, and metrics may differ.

#### Can I get historical TikTok hashtag trends?

The popularity curve covers the selected TikTok window when available, but the Actor does not provide an unlimited historical database. Schedule recurring runs if you need your own longitudinal dataset.

#### Can this predict whether a hashtag will go viral?

No. `momentum`, `volatility`, and `trendStage` summarize the curve TikTok exposes. They help prioritize research but do not predict future reach or guarantee campaign performance.

#### Why did my run finish as `PARTIAL`?

One or more country/period/industry requests failed after retries while other slices succeeded. Open the run's `OUTPUT` record to see the affected slices. If the problem persists, share the run URL in the Actor's Issues tab.

### Privacy, legality, and responsible use

This Actor only collects public trend-chart data and public creator information that TikTok chooses to expose. It does not access private profiles, messages, email addresses, phone numbers, hidden demographics, or user sessions.

Public results can still contain personal data, such as creator handles or profile links. Personal data is protected by the GDPR in the European Union and by other laws worldwide. Only collect and process it for a legitimate purpose, follow TikTok's applicable terms and local regulations, and consult legal counsel if you are unsure whether your use is permitted.

### Support

If a country, period, or industry slice stops returning expected data, open an issue from the Actor page and include:

- the Apify run URL or run ID;
- countries and periods used;
- whether industry scanning was enabled;
- expected versus actual result count;
- any relevant message from the run log or `OUTPUT` summary.

That information makes TikTok-side changes and reproducible extraction bugs much faster to diagnose.

# Actor input Schema

## `countries` (type: `array`):

TikTok country codes to scan.

## `periods` (type: `array`):

Lookback windows in days.

## `scanAllIndustries` (type: `boolean`):

Recommended: scans the public overall ranking plus every supported industry to discover more than the overall top three.

## `maxResults` (type: `integer`):

Unique hashtag rows to save. Use 0 for every result discoverable from the selected slices.

## `industryIds` (type: `array`):

Optional TikTok industry IDs. When set, these replace the all-industries scan.

## `requestDelayMs` (type: `integer`):

Increase if TikTok throttles requests.

## `requestRetries` (type: `integer`):

Retry transient TikTok request failures.

## Actor input object example

```json
{
  "countries": [
    "US"
  ],
  "periods": [
    "7"
  ],
  "scanAllIndustries": true,
  "maxResults": 25,
  "requestDelayMs": 150,
  "requestRetries": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "countries": [
        "US"
    ],
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/tiktok-hashtag-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 = {
    "countries": ["US"],
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/tiktok-hashtag-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 '{
  "countries": [
    "US"
  ],
  "maxResults": 25
}' |
apify call webdata_labs/tiktok-hashtag-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Hashtag Trends Scraper & Breakout Radar | $2/1K",
        "description": "Discover trending TikTok hashtags by country, industry, and period. Export views, posts, momentum, popularity curves, and top creators. $2 per 1,000 rows; platform usage included.",
        "version": "0.1",
        "x-build-id": "deeiOpM0W040wLMfM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~tiktok-hashtag-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-tiktok-hashtag-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/webdata_labs~tiktok-hashtag-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-tiktok-hashtag-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/webdata_labs~tiktok-hashtag-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-tiktok-hashtag-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",
                "required": [
                    "countries"
                ],
                "properties": {
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "TikTok country codes to scan.",
                        "default": [
                            "US"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "periods": {
                        "title": "Trend periods",
                        "type": "array",
                        "description": "Lookback windows in days.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "7",
                                "30",
                                "90"
                            ],
                            "enumTitles": [
                                "Last 7 days",
                                "Last 30 days",
                                "Last 90 days"
                            ]
                        },
                        "default": [
                            "7"
                        ]
                    },
                    "scanAllIndustries": {
                        "title": "Scan industry slices",
                        "type": "boolean",
                        "description": "Recommended: scans the public overall ranking plus every supported industry to discover more than the overall top three.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Unique hashtag rows to save. Use 0 for every result discoverable from the selected slices.",
                        "default": 25
                    },
                    "industryIds": {
                        "title": "Specific industry IDs",
                        "type": "array",
                        "description": "Optional TikTok industry IDs. When set, these replace the all-industries scan.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Increase if TikTok throttles requests.",
                        "default": 150
                    },
                    "requestRetries": {
                        "title": "Retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry transient TikTok request failures.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
