# TikTok Keywords Discovery Scraper (`automation-lab/tiktok-keywords-discovery`) Actor

Discover TikTok autocomplete keywords, related search phrases, and long-tail TikTok SEO ideas from public search preview data.

- **URL**: https://apify.com/automation-lab/tiktok-keywords-discovery.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Keywords Discovery Scraper

Find TikTok keyword ideas, autocomplete phrases, and long-tail search terms from public TikTok search preview data.

Use it for TikTok SEO, creator briefs, content calendars, product research, paid social planning, and recurring trend tracking.

The actor accepts seed keywords or TikTok search URLs, expands them, deduplicates suggestions, and saves clean rows you can export or use through the Apify API.

### 🚀 What does TikTok Keywords Discovery Scraper do?

TikTok Keywords Discovery Scraper turns seed terms into TikTok search suggestions.

For each seed keyword, it calls public TikTok web search preview endpoints and extracts suggested search phrases.

It can also run A-Z expansions such as `makeup a`, `makeup b`, or `meal prep c` for deeper long-tail discovery.

The output is structured for analysis, not screenshots or raw HTML.

You get the original seed, the exact suggestion, rank, region, language, search URL, and metadata returned by TikTok when available.

### 👥 Who is it for?

Content marketers use it to plan TikTok posts around phrases people already search for.

TikTok SEO specialists use it to collect autocomplete terms for optimization briefs.

UGC agencies use it to build creator briefs with real search language.

Ecommerce teams use it to discover product modifiers such as review, dupe, haul, tutorial, before and after, or comparison.

Affiliate publishers use it to find long-tail ideas before producing short-form reviews.

Data teams use it as a lightweight keyword feed for dashboards and trend monitoring.

### 💡 Why use TikTok keyword discovery?

Manual TikTok autocomplete research is slow.

It is hard to repeat consistently.

It is hard to export.

It is easy to miss long-tail modifiers.

This actor makes the process repeatable, API-friendly, and ready for scheduled runs.

You can save the same input and compare suggestions week over week.

You can also feed the suggestions into another TikTok video scraper for deeper content analysis.

### 📦 What data can you extract?

The actor outputs one row per keyword suggestion.

| Field | Description |
| --- | --- |
| `seedKeyword` | Original keyword used as the discovery seed |
| `expansionKeyword` | Exact query sent to TikTok, including A-Z suffixes when enabled |
| `suggestion` | Suggested TikTok search phrase |
| `normalizedSuggestion` | Lowercase normalized suggestion for deduplication |
| `suggestionRank` | Order returned by TikTok for that query |
| `searchUrl` | TikTok search URL for the suggestion |
| `region` | Region code used in the request |
| `language` | Language header used in the request |
| `groupId` | TikTok group identifier when returned |
| `wordsSource` | TikTok words source metadata when returned |
| `recallReason` | TikTok recall reason metadata when returned |
| `flags` | Additional boolean or text flags when returned |
| `fetchedAt` | ISO timestamp for the extraction |

### 💰 How much does it cost to discover TikTok keywords?

The actor uses pay-per-event pricing: a small start charge plus a per-item charge for every saved keyword suggestion.

| Charge | Free plan | Bronze | Silver | Gold | Platinum | Diamond |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run start | $0.005 per run | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Keyword suggestion saved | $0.000032806 | $0.000028527 | $0.000022251 | $0.000017116 | $0.000011411 | $0.000010000 |

Example Free-plan estimates:

| Example run | Estimated charge |
| --- | ---: |
| 1 seed × 10 suggestions | about $0.00533 |
| 5 seeds × 25 suggestions | about $0.00910 |
| 10 seeds × 50 suggestions | about $0.02140 |
| 2 seeds with A-Z expansions and 500 saved suggestions | about $0.02140 |

Actual cost depends on how many unique suggestions are saved. For larger recurring workflows, tiered pricing lowers the per-item cost on higher Apify plans. The Apify Pricing tab remains the source of truth if platform prices change.

### 🧭 How to use it

1. Open the actor on Apify.

2. Add one or more seed keywords, for example `makeup`, `fitness`, or `meal prep`.

3. Keep `Max suggestions per keyword` low for your first run.

4. Choose a region and language if your campaign is localized.

5. Enable A-Z expansions when you need broader long-tail coverage.

6. Start the actor.

7. Export the dataset as JSON, CSV, Excel, XML, RSS, or access it through the API.

### 🔎 Input options

`keywords` is the main input.

Use it for seed TikTok search phrases such as `skincare routine`, `budget travel`, or `protein recipes`.

`searchUrls` accepts TikTok search URLs and reads common query parameters such as `q`, `keyword`, and `search_query`.

`maxSuggestionsPerKeyword` limits unique suggestions saved for each seed.

`region` sends a two-letter region code to TikTok's public web endpoint.

`language` sets the request language header, such as `en-US` or `de-DE`.

`includeAlphabetExpansions` queries every seed plus `a` through `z` suffixes.

### 🧪 Recommended input examples

Small test run:

```json
{
  "keywords": ["makeup"],
  "maxSuggestionsPerKeyword": 10,
  "region": "US",
  "language": "en-US",
  "includeAlphabetExpansions": false
}
````

Long-tail discovery run:

```json
{
  "keywords": ["meal prep", "skincare"],
  "maxSuggestionsPerKeyword": 25,
  "region": "US",
  "language": "en-US",
  "includeAlphabetExpansions": true
}
```

Search URL run:

```json
{
  "searchUrls": [{ "url": "https://www.tiktok.com/search?q=fitness" }],
  "maxSuggestionsPerKeyword": 20
}
```

### 📤 Output example

```json
{
  "seedKeyword": "makeup",
  "expansionKeyword": "makeup",
  "suggestion": "makeup inspo",
  "normalizedSuggestion": "makeup inspo",
  "suggestionRank": 2,
  "searchUrl": "https://www.tiktok.com/search?q=makeup%20inspo",
  "region": "US",
  "language": "en-US",
  "groupId": "",
  "wordsSource": "",
  "recallReason": "",
  "flags": [],
  "fetchedAt": "2026-05-25T09:00:00.000Z"
}
```

### 📊 Example workflow: content calendar planning

Start with broad seeds for your niche.

Collect suggestions from TikTok.

Group phrases by intent: tutorial, review, challenge, recipe, ideas, outfit, aesthetic, comparison, and troubleshooting.

Turn each group into weekly video briefs.

Rerun the same input monthly to monitor whether new modifiers appear.

### 🛒 Example workflow: ecommerce product research

Enter product category seeds such as `portable blender`, `running shoes`, or `hair oil`.

Enable A-Z expansions to reveal buyer modifiers.

Look for phrases containing review, before and after, worth it, dupe, Amazon, TikTok made me buy it, or how to use.

Export suggestions to your merchandising, ads, or creator team.

### 🧑‍💼 Example workflow: agency reporting

Create a saved input per client.

Schedule recurring runs.

Export CSV or use the Apify API to load results into a dashboard.

Show clients which TikTok search phrases are available for content planning.

Combine the keyword output with video performance data from related TikTok scrapers.

### 🔗 Integrations

Send output to Google Sheets for editorial planning.

Send output to Airtable for campaign management.

Use Make or Zapier to trigger downstream workflows after each run.

Load the dataset into a warehouse for trend monitoring.

Feed suggestions to TikTok video scraping actors to collect matching posts.

Use the Apify API in your own internal keyword research tools.

### 🧑‍💻 API usage

Use actor ID `automation-lab/tiktok-keywords-discovery`.

Node.js example:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/tiktok-keywords-discovery').call({
  keywords: ['makeup', 'meal prep'],
  maxSuggestionsPerKeyword: 10,
  region: 'US',
  language: 'en-US',
  includeAlphabetExpansions: false,
});

console.log(`Dataset: ${run.defaultDatasetId}`);
```

Python example:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/tiktok-keywords-discovery').call(run_input={
    'keywords': ['makeup', 'meal prep'],
    'maxSuggestionsPerKeyword': 10,
    'region': 'US',
    'language': 'en-US',
    'includeAlphabetExpansions': False,
})
print('Dataset:', run['defaultDatasetId'])
```

cURL example:

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~tiktok-keywords-discovery/runs?token='$APIFY_TOKEN \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["makeup","meal prep"],"maxSuggestionsPerKeyword":10,"region":"US","language":"en-US","includeAlphabetExpansions":false}'
```

### 🤖 MCP setup for Claude and agents

This actor is available through Apify MCP.

Use this MCP server URL when configuring Claude Desktop, Claude Code, Cursor, VS Code, or another MCP client:

```text
https://mcp.apify.com/?tools=automation-lab/tiktok-keywords-discovery
```

The `tools` query parameter matters because it exposes this actor directly instead of the full Apify tool catalog.

Claude Code setup:

```bash
claude mcp add --transport http apify-tiktok-keywords "https://mcp.apify.com/?tools=automation-lab/tiktok-keywords-discovery" --header "Authorization: Bearer $APIFY_TOKEN"
```

Claude Desktop, Cursor, and VS Code MCP JSON config:

```json
{
  "mcpServers": {
    "apify-tiktok-keywords": {
      "url": "https://mcp.apify.com/?tools=automation-lab/tiktok-keywords-discovery",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

If your MCP client does not expand environment variables inside JSON, replace `${APIFY_TOKEN}` with your Apify API token. Keep the actor-specific `tools` URL so the client only exposes the TikTok Keywords Discovery tool.

Claude Desktop prompt example:

```text
Use the TikTok Keywords Discovery Scraper to find 30 keyword ideas for vegan meal prep in the US. Return the suggestions grouped by breakfast, lunch, dinner, and snacks.
```

Claude Code prompt example:

```text
Call automation-lab/tiktok-keywords-discovery with keywords ["skincare routine", "hair oil"] and maxSuggestionsPerKeyword 20. Save the resulting dataset URL in my project notes.
```

Agent workflow prompt example:

```text
Run TikTok keyword discovery for this product list, then create a CSV of suggested TikTok search URLs for the marketing team.
```

### ⚖️ Legality and responsible use

This actor reads public TikTok web preview data.

It does not log in.

It does not access private accounts.

It does not bypass authentication-only features.

Use the output responsibly and follow TikTok terms, Apify terms, and applicable laws in your jurisdiction.

Do not use the actor to collect private or sensitive personal data.

### 🧯 Troubleshooting

If a seed returns fewer suggestions than requested, TikTok may have returned fewer suggestions for that term.

If a run returns no results, try a broader seed keyword first.

If A-Z expansion takes longer than expected, reduce the number of seeds or lower the per-keyword limit.

If metadata fields are empty, TikTok did not include those fields in the public response.

If localization looks different than expected, test another `region` and `language` pair.

### 🧱 Limitations

This actor discovers keywords and search suggestions.

It is not a TikTok video scraper.

It does not scrape comments, profiles, private content, or authenticated pages.

Suggestions depend on what TikTok returns at run time.

TikTok endpoint changes may require actor maintenance.

### 🛡️ Reliability notes

The implementation is HTTP-only and lightweight.

It avoids browser automation for faster and cheaper runs.

The actor deduplicates suggestions across seeds and expansions.

It skips empty or malformed suggestions gracefully.

It records `fetchedAt` so scheduled runs can be compared over time.

### ✅ Best practices

Start with 1-3 broad seeds.

Review the first dataset before running large A-Z expansion jobs.

Use saved inputs for repeatable monthly tracking.

Keep region and language consistent when comparing runs over time.

Rerun high-value suggestions as new seed keywords.

Combine keyword output with video scraping only after you know which phrases matter.

### 🧩 Related scrapers

Use related automation-lab actors when you need more TikTok data after keyword discovery.

- https://apify.com/automation-lab/tiktok-scraper

- https://apify.com/automation-lab/tiktok-search-scraper

- https://apify.com/automation-lab/tiktok-trends-scraper

- https://apify.com/automation-lab/tiktok-video-scraper

### 📚 FAQ

Can I scrape TikTok videos with this actor?

No. This actor discovers keyword suggestions. Use a TikTok video scraper for video details.

Does it need a TikTok account?

No. It uses public web preview data.

Can I choose country and language?

Yes. Use `region` and `language` inputs.

Why do some fields come back empty?

TikTok does not always include every metadata field for every suggestion.

Can I schedule this actor?

Yes. Apify schedules are useful for recurring keyword monitoring.

### 🏁 Getting started checklist

Choose one seed keyword.

Set `maxSuggestionsPerKeyword` to 10.

Run the actor.

Open the dataset preview.

Export CSV or connect the API.

Increase limits only after confirming the output matches your research goal.

# Actor input Schema

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

TikTok search terms to expand into related autocomplete phrases.

## `searchUrls` (type: `array`):

Optional TikTok search URLs. The actor reads q, keyword, or search\_query parameters as seed keywords.

## `maxSuggestionsPerKeyword` (type: `integer`):

Maximum unique keyword suggestions to save for each seed keyword.

## `region` (type: `string`):

Two-letter region code sent to TikTok's public web endpoint.

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

Browser language sent in request headers, for example en-US or de-DE.

## `includeAlphabetExpansions` (type: `boolean`):

Also query each seed plus a-z suffixes (for example 'makeup a', 'makeup b') to discover more long-tail ideas. Uses more requests.

## Actor input object example

```json
{
  "keywords": [
    "makeup",
    "fitness",
    "meal prep"
  ],
  "searchUrls": [
    {
      "url": "https://www.tiktok.com/search?q=makeup"
    }
  ],
  "maxSuggestionsPerKeyword": 20,
  "region": "US",
  "language": "en-US",
  "includeAlphabetExpansions": false
}
```

# Actor output Schema

## `keywordSuggestions` (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 = {
    "keywords": [
        "makeup",
        "fitness",
        "meal prep"
    ],
    "searchUrls": [
        {
            "url": "https://www.tiktok.com/search?q=makeup"
        }
    ],
    "region": "US",
    "language": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tiktok-keywords-discovery").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 = {
    "keywords": [
        "makeup",
        "fitness",
        "meal prep",
    ],
    "searchUrls": [{ "url": "https://www.tiktok.com/search?q=makeup" }],
    "region": "US",
    "language": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tiktok-keywords-discovery").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 '{
  "keywords": [
    "makeup",
    "fitness",
    "meal prep"
  ],
  "searchUrls": [
    {
      "url": "https://www.tiktok.com/search?q=makeup"
    }
  ],
  "region": "US",
  "language": "en-US"
}' |
apify call automation-lab/tiktok-keywords-discovery --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Keywords Discovery Scraper",
        "description": "Discover TikTok autocomplete keywords, related search phrases, and long-tail TikTok SEO ideas from public search preview data.",
        "version": "0.1",
        "x-build-id": "y9KocYMgJkFjNt2fl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tiktok-keywords-discovery/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tiktok-keywords-discovery",
                "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/automation-lab~tiktok-keywords-discovery/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tiktok-keywords-discovery",
                "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/automation-lab~tiktok-keywords-discovery/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tiktok-keywords-discovery",
                "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": {
                    "keywords": {
                        "title": "Seed keywords",
                        "type": "array",
                        "description": "TikTok search terms to expand into related autocomplete phrases.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "TikTok search URLs",
                        "type": "array",
                        "description": "Optional TikTok search URLs. The actor reads q, keyword, or search_query parameters as seed keywords.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxSuggestionsPerKeyword": {
                        "title": "Max suggestions per keyword",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum unique keyword suggestions to save for each seed keyword.",
                        "default": 20
                    },
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "Two-letter region code sent to TikTok's public web endpoint.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Browser language sent in request headers, for example en-US or de-DE.",
                        "default": "en-US"
                    },
                    "includeAlphabetExpansions": {
                        "title": "Include A-Z expansions",
                        "type": "boolean",
                        "description": "Also query each seed plus a-z suffixes (for example 'makeup a', 'makeup b') to discover more long-tail ideas. Uses more requests.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```