# TikTok Search Scraper (`paul_44/tiktok-search`) Actor

Scrape TikTok videos by keyword. Extract title, views, likes, author, hashtags, play URLs, thumbnails. Supports date range, region, sort order, min views/duration filters, strict keyword matching (Korean NFKC), residential proxy, and session caching.

- **URL**: https://apify.com/paul\_44/tiktok-search.md
- **Developed by:** [paul\_44](https://apify.com/paul_44) (community)
- **Categories:** Social media, Videos, E-commerce
- **Stats:** 4 total users, 2 monthly users, 97.2% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.60 / 1,000 video results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

TikTok Search Scraper extracts structured video data from TikTok search results by keyword — including views, likes, comments, shares, hashtags, author info, upload date, thumbnails, and playable preview URLs. Run a single keyword or a batch of hundreds; filter by date, region, view count, or minimum duration; and get clean JSON ready for analytics, dashboards, or content research.

### What does TikTok Search Scraper do?

Given one or more search keywords, this Actor calls TikTok's search API through a residential proxy and returns every video it can collect, up to your chosen `maxItems`. Results come back as a flat dataset where each row is one video with consistent field names, so you can plug the output straight into BigQuery, Postgres, Google Sheets, Zapier, Make, n8n — anywhere Apify integrates.

It is a drop-in replacement for manually browsing `tiktok.com/search` and is built for teams that need:

- **Marketing research** — tracking trending content in specific niches
- **Brand monitoring** — who is posting about your product / keyword
- **Influencer discovery** — surfacing creators by region and engagement
- **Competitive analysis** — hashtag velocity, view distribution, top posts
- **Content intelligence** — feeding AI pipelines with TikTok context

### What data can TikTok Search Scraper extract?

For every video returned, you get:

- **Identifiers** — `id`, canonical TikTok URL, embed URL
- **Content** — `title` (first line of description), full `hashtags`, `uploadedAt` (Unix seconds)
- **Engagement stats** — `views`, `likes`, `comments`, `shares`
- **Author / channel** — `username`, display `name`, profile `url`, `followers`, `avatar`
- **Video metadata** — `duration`, direct `videoUrl`, HLS preview, play URL candidates
- **Media** — stable `thumbnail` URL and optional stable preview for in-Console playback
- **Keyword relevance** — `keywordRelevance` (`high` / `none`) and `keywordMatchedIn` list so you can post-filter fuzzy TikTok matches

See the [Output](#output) section for a complete JSON sample.

### How do I use TikTok Search Scraper to scrape TikTok?

1. Click **Try for free** at the top of this page and sign in to Apify (free account works).
2. Open the **Input** tab on the Actor run page.
3. Enter one or more keywords in the `keywords` list — one search is run per keyword.
4. (Optional) Choose **Upload date**, **Sort by**, **Region**, **Min views**, or **Min duration** to narrow the results.
5. (Optional) Toggle **Strict keyword match** to drop TikTok's fuzzy unrelated results.
6. Click **Start**. The run takes roughly 10–30 seconds per 50 videos depending on keyword popularity and region.
7. When the run finishes, open the **Storage** → **Dataset** tab to preview results, or export as JSON / CSV / Excel / HTML.

You can also [call the Actor via API](#usage-via-api), schedule it from Apify Console, or chain it into an Apify workflow.

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

Pricing is **from $0.60 per 1,000 video results** on Apify Store. You only pay for successful results — failed runs are free. New Apify accounts include free monthly platform credits.

### Input

Configure the run via the **Input** tab in Apify Console or pass JSON via API.

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keywords` | string[] | — | Search keywords. One search per keyword. |
| `keyword` | string | — | Single-keyword fallback when `keywords` is empty. |
| `maxItems` | integer | 50 | Max results per keyword (1–1000). |
| `dateRange` | string | `all` | `all`, `today`, `yesterday`, `7days`, `1month`, `3months`, `6months`. |
| `sortType` | string | `RELEVANCE` | `RELEVANCE`, `MOST_LIKED`, or `LATEST`. |
| `location` | string | `US` | ISO 3166-1 alpha-2 country code (`US`, `KR`, `JP`, `GB`, `DE`, …). |
| `minPlayCount` | integer | 0 | Exclude videos below this view count. |
| `minDurationSec` | number | 0 | Exclude videos shorter than N seconds. |
| `strictKeywordMatch` | boolean | `false` | When OFF: all results returned with `keywordRelevance` tag. When ON: drops videos where keyword does not appear in title / description / hashtags / author. |
| `mirrorVideos` | boolean | `true` | Store preview clips in Apify KV Store for stable Console playback. |
| `includeSearchKeywords` | boolean | `false` | Adds `searchKeyword` field to each result. |
| `maxConcurrentKeywords` | integer | 1 | Run N keyword searches in parallel (1–16). |
| `proxyConfiguration` | object | Apify RESIDENTIAL | Apify proxy group / country. |

#### Input example

```json
{
  "keywords": ["BTS", "BLACKPINK", "aespa"],
  "maxItems": 100,
  "dateRange": "7days",
  "sortType": "MOST_LIKED",
  "location": "KR",
  "minPlayCount": 10000,
  "strictKeywordMatch": true
}
````

### Output

Results land in the default dataset with one JSON object per video. Sample row:

```json
{
  "id": "7628238301794766101",
  "title": "HBD to meeeee #aespa #KARINA #카리나",
  "views": 1250000,
  "likes": 98000,
  "comments": 3200,
  "shares": 1500,
  "hashtags": ["aespa", "KARINA", "카리나"],
  "uploadedAt": 1713200000,
  "channel": {
    "username": "karina.aespa",
    "name": "KARINA",
    "url": "https://www.tiktok.com/@karina.aespa",
    "followers": 5200000,
    "avatar": "https://p16-sign.tiktokcdn-us.com/..."
  },
  "video": {
    "duration": 15,
    "url": "https://v16-webapp.tiktok.com/...",
    "thumbnail": "https://p16-sign.tiktokcdn-us.com/...",
    "cover": "https://p16-sign.tiktokcdn-us.com/..."
  },
  "url": "https://www.tiktok.com/@karina.aespa/video/7628238301794766101",
  "videoUrl": "https://v16-webapp.tiktok.com/...",
  "downloadUrl": "https://v16-webapp.tiktok.com/...",
  "thumbnail": "https://p16-sign.tiktokcdn-us.com/...",
  "tiktokEmbedUrl": "https://www.tiktok.com/embed/v2/7628238301794766101",
  "keywordRelevance": "high",
  "keywordMatchedIn": ["desc", "hashtags"]
}
```

A full field reference lives in `.actor/dataset_schema.json` and is rendered as the **Overview** tab on the dataset page in Apify Console.

### Usage via API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["BTS", "BLACKPINK"],
    "maxItems": 50,
    "dateRange": "7days",
    "sortType": "MOST_LIKED",
    "location": "KR"
  }'
```

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("YOUR_ACTOR_ID").call(run_input={
    "keywords": ["BTS"],
    "maxItems": 50,
    "dateRange": "7days",
    "sortType": "MOST_LIKED",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["views"])
```

#### JavaScript (apify-client)

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('YOUR_ACTOR_ID').call({
    keywords: ['BTS'],
    maxItems: 50,
    dateRange: '7days',
    sortType: 'MOST_LIKED',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(item.title, item.views));
```

### FAQ

#### Is scraping TikTok legal?

Scraping publicly available data is generally permitted, but you are responsible for complying with TikTok's Terms of Service and applicable law (GDPR, CCPA, local data-protection rules). Do not use this Actor to collect personal data without a lawful basis, and avoid redistributing downloaded video files without the creator's permission.

#### Why does a keyword sometimes return fewer results than `maxItems`?

TikTok's search API stops returning items once it decides it has shown you "enough" matches, especially for niche or very new keywords. The Actor will collect as many as TikTok serves and then stop — it never fabricates rows.

#### Why do some `videoUrl` / `downloadUrl` links stop working after a few hours?

TikTok URLs expire after a short period. For persistent playback use the `previewVideoUrl` field (enabled by `mirrorVideos=true`, default ON) — it stays stable.

#### What is `keywordRelevance` for?

TikTok's search is intentionally fuzzy and often mixes in unrelated videos. Every result is tagged `high` (keyword found in title / description / hashtags / author) or `none` (fuzzy match). Leave `strictKeywordMatch` off to inspect both; turn it on to drop `none` rows at scrape time.

#### Does this Actor support `@username` / video URL input?

No — this Actor is keyword-search only. Profile and single-video extraction are outside its scope.

#### Can I run this Actor on a schedule?

Yes. Use **Schedules** in Apify Console to trigger runs at any cron interval and forward the dataset to a webhook, spreadsheet, or database.

#### Which URL should I use to embed a video preview on my site?

Use the **`tiktokEmbedUrl`** field. It points to TikTok's `/embed/v2/` endpoint, which is the most permissive embed URL TikTok offers and works across the widest range of videos. Avoid TikTok's newer `/player/v1/` endpoint — it rejects (HTTP 403) certain older videos or videos whose uploader tightened embed settings, even though the same videos play fine in `/embed/v2/`.

### Limitations and disclaimers

- This Actor is **not affiliated with or endorsed by TikTok**.
- Expect occasional missing fields when TikTok omits them for a given video (null-safe in the schema).
- Video download URLs are time-limited — re-scrape when needed.
- Result ordering depends on TikTok's algorithm and varies by region and time.

### Support

Found a bug or have a feature request? Open an issue on the Actor's issue tracker, or contact the maintainer via Apify Console's **Submit feedback** button at the top of the Actor page. Include a run ID and the input JSON so issues can be reproduced quickly.

# Actor input Schema

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

Search keywords. Each keyword runs a separate search.

## `keyword` (type: `string`):

Used only when 'keywords' list is empty.

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

Maximum number of videos to return per keyword. Higher values increase run time and cost — start with 50 for exploration.

## `dateRange` (type: `string`):

Filter by upload date.

## `sortType` (type: `string`):

RELEVANCE = best match, MOST\_LIKED = most likes, LATEST = newest first.

## `location` (type: `string`):

Country code for search results (ISO 3166-1 alpha-2).

## `minPlayCount` (type: `integer`):

Exclude videos with fewer views than this. 0 = no filter. Low thresholds return more results but include low-quality content.

## `strictKeywordMatch` (type: `boolean`):

Filter out videos where the keyword does not appear in title, description, hashtags, or author name. OFF by default: all results are returned with keywordRelevance field (high/none). Turn ON to remove unrelated results.

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

Apify Proxy configuration. Default uses RESIDENTIAL proxies.

## `mirrorVideos` (type: `boolean`):

Provide a stable preview URL that stays playable in Console after TikTok's original URL expires.

## `mirrorVideoBytes` (type: `integer`):

Bytes per preview clip. Default 262144 = 256 KB. Larger values play longer clips but use more storage and bandwidth.

## `minDurationSec` (type: `number`):

Exclude videos shorter than this many seconds. 0 = no filter.

## `maxConcurrentKeywords` (type: `integer`):

Number of keywords to search in parallel. Higher = faster but memory usage scales linearly. Recommended: 1–4 at 2 GB memory, up to 16 at 8 GB+.

## `useProxy` (type: `boolean`):

Use Apify RESIDENTIAL proxy. Disable to save bandwidth (may get blocked).

## `includeSearchKeywords` (type: `boolean`):

Add searchKeyword field to each result item.

## `msToken` (type: `string`):

TikTok auth token. Leave empty — the Actor handles this automatically (recommended).

## Actor input object example

```json
{
  "keywords": [
    "BTS"
  ],
  "maxItems": 50,
  "dateRange": "all",
  "sortType": "RELEVANCE",
  "location": "US",
  "minPlayCount": 0,
  "strictKeywordMatch": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "mirrorVideos": true,
  "mirrorVideoBytes": 262144,
  "minDurationSec": 0,
  "maxConcurrentKeywords": 1,
  "useProxy": true,
  "includeSearchKeywords": false
}
```

# 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": [
        "BTS"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("paul_44/tiktok-search").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": ["BTS"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("paul_44/tiktok-search").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": [
    "BTS"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call paul_44/tiktok-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Search Scraper",
        "description": "Scrape TikTok videos by keyword. Extract title, views, likes, author, hashtags, play URLs, thumbnails. Supports date range, region, sort order, min views/duration filters, strict keyword matching (Korean NFKC), residential proxy, and session caching.",
        "version": "0.0",
        "x-build-id": "FppXTCZqd1coCip71"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/paul_44~tiktok-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-paul_44-tiktok-search",
                "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/paul_44~tiktok-search/runs": {
            "post": {
                "operationId": "runs-sync-paul_44-tiktok-search",
                "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/paul_44~tiktok-search/run-sync": {
            "post": {
                "operationId": "run-sync-paul_44-tiktok-search",
                "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": "Keywords",
                        "minItems": 0,
                        "type": "array",
                        "description": "Search keywords. Each keyword runs a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Single keyword (fallback)",
                        "type": "string",
                        "description": "Used only when 'keywords' list is empty."
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of videos to return per keyword. Higher values increase run time and cost — start with 50 for exploration.",
                        "default": 50
                    },
                    "dateRange": {
                        "title": "Upload date",
                        "enum": [
                            "all",
                            "today",
                            "yesterday",
                            "7days",
                            "1month",
                            "3months",
                            "6months"
                        ],
                        "type": "string",
                        "description": "Filter by upload date.",
                        "default": "all"
                    },
                    "sortType": {
                        "title": "Sort by",
                        "enum": [
                            "RELEVANCE",
                            "MOST_LIKED",
                            "LATEST"
                        ],
                        "type": "string",
                        "description": "RELEVANCE = best match, MOST_LIKED = most likes, LATEST = newest first.",
                        "default": "RELEVANCE"
                    },
                    "location": {
                        "title": "Region",
                        "enum": [
                            "US",
                            "GB",
                            "KR",
                            "JP",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "BR",
                            "MX",
                            "ID",
                            "VN",
                            "PH",
                            "TH",
                            "TR",
                            "IN",
                            "RU",
                            "CA",
                            "AU"
                        ],
                        "type": "string",
                        "description": "Country code for search results (ISO 3166-1 alpha-2).",
                        "default": "US"
                    },
                    "minPlayCount": {
                        "title": "Min views",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Exclude videos with fewer views than this. 0 = no filter. Low thresholds return more results but include low-quality content.",
                        "default": 0
                    },
                    "strictKeywordMatch": {
                        "title": "Strict keyword match",
                        "type": "boolean",
                        "description": "Filter out videos where the keyword does not appear in title, description, hashtags, or author name. OFF by default: all results are returned with keywordRelevance field (high/none). Turn ON to remove unrelated results.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify Proxy configuration. Default uses RESIDENTIAL proxies.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "mirrorVideos": {
                        "title": "Stable video previews",
                        "type": "boolean",
                        "description": "Provide a stable preview URL that stays playable in Console after TikTok's original URL expires.",
                        "default": true
                    },
                    "mirrorVideoBytes": {
                        "title": "Preview clip size (bytes)",
                        "minimum": 65536,
                        "maximum": 10485760,
                        "type": "integer",
                        "description": "Bytes per preview clip. Default 262144 = 256 KB. Larger values play longer clips but use more storage and bandwidth.",
                        "default": 262144
                    },
                    "minDurationSec": {
                        "title": "Min video duration",
                        "minimum": 0,
                        "type": "number",
                        "description": "Exclude videos shorter than this many seconds. 0 = no filter.",
                        "default": 0
                    },
                    "maxConcurrentKeywords": {
                        "title": "Parallel keywords",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of keywords to search in parallel. Higher = faster but memory usage scales linearly. Recommended: 1–4 at 2 GB memory, up to 16 at 8 GB+.",
                        "default": 1
                    },
                    "useProxy": {
                        "title": "Use residential proxy",
                        "type": "boolean",
                        "description": "Use Apify RESIDENTIAL proxy. Disable to save bandwidth (may get blocked).",
                        "default": true
                    },
                    "includeSearchKeywords": {
                        "title": "Include search keyword in results",
                        "type": "boolean",
                        "description": "Add searchKeyword field to each result item.",
                        "default": false
                    },
                    "msToken": {
                        "title": "msToken (optional)",
                        "type": "string",
                        "description": "TikTok auth token. Leave empty — the Actor handles this automatically (recommended)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
