# Douyin Analytics Scraper (`automation-lab/douyin-analytics-scraper`) Actor

Extract Douyin trending hot search topics, video search results, and user profile analytics. Get real-time rankings, engagement metrics, and follower counts. No login or API key required.

- **URL**: https://apify.com/automation-lab/douyin-analytics-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 7 total users, 6 monthly users, 100.0% runs succeeded, NaN 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

## Douyin Analytics Scraper

Extract trending topics, search results, and user profile analytics from **Douyin** (抖音) — the Chinese version of TikTok. Get real-time hot search rankings, engagement metrics, follower counts, and video statistics. No login or API key required.

### What does Douyin Analytics Scraper do?

**Douyin Analytics Scraper** pulls structured analytics data directly from [Douyin's](https://www.douyin.com/) internal APIs. It supports three scraping modes:

- 🔥 **Trending** — Fetch the current hot search list (up to 52 topics with hot values, video counts, and cover images). Works via pure HTTP — no browser required, results in seconds.
- 🔍 **Search** — Search Douyin by keyword and extract video or user results with engagement metrics (plays, likes, comments, shares).
- 👤 **User Profile** — Scrape user profile analytics: follower count, following count, total video count, total likes received, and verification status.

Douyin is the #1 short-video platform in China with 700+ million daily active users. Marketers, researchers, and brands use this scraper to monitor Chinese social media trends without needing a Chinese phone number, VPN, or API access.

### Who is Douyin Analytics Scraper for?

**🎯 Market Researchers**
- Track what topics are trending in China right now
- Monitor competitor brand mentions and engagement on Douyin
- Export trend data to CSV/Excel for reports and presentations

**📊 Digital Marketers & Brand Managers**
- Identify viral content formats and hashtag strategies for Chinese audiences
- Monitor Key Opinion Leaders (KOLs) follower growth and engagement rates
- Benchmark your brand's Douyin performance against competitors

**🧑‍💻 Developers & Data Scientists**
- Feed real-time Chinese social trends into NLP pipelines or dashboards
- Build Douyin monitoring tools using Apify's API and scheduling features
- Integrate with Google Sheets, Slack, or BI tools via Zapier/Make

**🌏 International Business Teams**
- Monitor brand reputation on China's most-used social platform
- Research market demand for products by tracking search trends
- Identify KOL partners by analyzing profile metrics at scale

### Why use Douyin Analytics Scraper?

- ✅ **Actually works** — trending mode uses a direct API endpoint, delivering results in under 10 seconds
- ✅ **No login required** — no Douyin account, no Chinese phone number, no VPN needed
- ✅ **Real-time data** — trending topics refresh every few minutes
- ✅ **Chinese text support** — search with Chinese characters (e.g., 美食, 娱乐, 时尚)
- ✅ **Structured output** — clean JSON with field names in English, timestamps in ISO 8601
- ✅ **Multiple modes** — trending, search, and user profile in one actor
- ✅ **Apify platform** — schedule runs, export to 20+ formats, integrate with 5,000+ apps

### What data can you extract?

#### 🔥 Trending Hot Search Topics

| Field | Description |
|-------|-------------|
| `rank` | Current position in the hot search list (1 = #1 trending) |
| `word` | Trending search term (Chinese) |
| `hotValue` | Numerical hot value score (higher = more trending) |
| `videoCount` | Number of videos about this topic |
| `discussVideoCount` | Discussion video count |
| `coverImageUrl` | Cover image URL for the trending topic |
| `eventTime` | When the topic started trending (ISO 8601) |
| `sentenceTag` | Category tag code |
| `groupId` | Douyin group ID for this trend |

#### 🔍 Search Results — Videos

| Field | Description |
|-------|-------------|
| `videoId` | Douyin video ID |
| `description` | Video caption/description |
| `playCount` | Total play count |
| `likeCount` | Total likes (digg count) |
| `commentCount` | Total comments |
| `shareCount` | Total shares |
| `collectCount` | Total saves/collects |
| `duration` | Video duration in seconds |
| `authorUniqueId` | Author's unique username |
| `authorNickname` | Author's display name |
| `authorFollowerCount` | Author's follower count |
| `musicTitle` | Background music title |
| `coverImageUrl` | Video thumbnail URL |
| `createTime` | Video creation time (ISO 8601) |

#### 👤 User Profile Analytics

| Field | Description |
|-------|-------------|
| `uniqueId` | User's unique username |
| `nickname` | Display name |
| `followerCount` | Total follower count |
| `followingCount` | Total following count |
| `videoCount` | Total videos published |
| `totalLikeCount` | Total likes received across all videos |
| `verified` | Whether the account is verified |
| `signature` | Bio/signature text |
| `region` | Account region |
| `avatarUrl` | Profile picture URL |

### How much does it cost to scrape Douyin data?

Douyin Analytics Scraper uses **Pay-Per-Event (PPE)** pricing — you only pay for results extracted, not for time spent. There's a one-time start fee plus a per-result charge with volume discounts.

| Plan | Start Fee | Per Result | 100 trending topics |
|------|-----------|-----------|---------------------|
| Free ($5 credit) | $0.05 | $0.0173 | ~$1.78 |
| Starter (BRONZE) | $0.05 | $0.0156 | ~$1.61 |
| Scale (SILVER) | $0.05 | $0.0121 | ~$1.26 |
| Business (GOLD) | $0.05 | $0.0095 | ~$1.00 |

**Real-world cost examples:**
- Scrape today's top 50 Douyin trending topics: ~$0.92
- Search for 30 videos about a keyword: ~$0.57
- Get analytics for 10 user profiles: ~$0.22

**Free tier estimate:** With $5 free Apify credits, you can extract approximately 280 results.

> **Tip:** The trending mode returns 47–52 topics per run in one batch. Running it daily costs less than $1/day.

### How to scrape Douyin trending topics

1. Go to [Douyin Analytics Scraper](https://apify.com/automation-lab/douyin-analytics-scraper) on Apify Store
2. Click **Try for free**
3. Select **Mode**: `🔥 Trending Hot Search`
4. Set **Max Results** to the number of topics you want (up to 52)
5. Click **Start** — results appear in seconds
6. Export as JSON, CSV, or Excel from the **Dataset** tab

#### Input examples

**Get today's top 30 trending topics:**
```json
{
    "mode": "trending",
    "maxResults": 30
}
````

**Search Douyin for food videos:**

```json
{
    "mode": "search",
    "keywords": ["美食", "烹饪"],
    "searchType": "video",
    "maxResults": 50
}
```

**Get user profile analytics:**

```json
{
    "mode": "userProfile",
    "userUrls": [
        "https://www.douyin.com/user/MS4wLjABAAAAexample1",
        "https://www.douyin.com/user/MS4wLjABAAAAexample2"
    ],
    "maxResults": 10
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `trending` | Scraping mode: `trending`, `search`, or `userProfile` |
| `keywords` | array | — | Search keywords (Chinese text supported). Used in `search` mode. |
| `searchType` | string | `video` | Type of search results: `video` or `user` |
| `userUrls` | array | — | Douyin user profile URLs. Used in `userProfile` mode. |
| `maxResults` | integer | 30 | Maximum results to extract (1–200) |
| `proxy` | object | Residential | Proxy configuration. Residential proxies recommended for search/profile modes. |

### Output examples

**Trending topic:**

```json
{
    "type": "trending",
    "rank": 1,
    "word": "美载人绕月任务火箭发射升空",
    "hotValue": 12023661,
    "videoCount": 3,
    "discussVideoCount": 1,
    "coverImageUrl": "https://p3-sign.douyinpic.com/...",
    "eventTime": "2026-04-01T23:14:58.000Z",
    "sentenceId": "2451921",
    "groupId": "7622673640848725299",
    "scrapedAt": "2026-04-02T00:05:36.536Z"
}
```

**Search result (video):**

```json
{
    "type": "searchVideo",
    "keyword": "美食",
    "videoId": "7318862563519600898",
    "description": "今天分享一道简单美味的家常菜",
    "playCount": 1250000,
    "likeCount": 89400,
    "commentCount": 1230,
    "shareCount": 4500,
    "duration": 45,
    "authorUniqueId": "foodlover2024",
    "authorNickname": "美食达人小明",
    "authorFollowerCount": 450000,
    "musicTitle": "背景音乐",
    "scrapedAt": "2026-04-02T00:10:00.000Z"
}
```

### Tips for best results

- 🔥 **Use trending mode for fast, free results** — it works via pure HTTP without proxies
- 🌏 **Residential proxy is required for search/profile modes** — Douyin's anti-bot protection blocks datacenter IPs. The actor automatically uses residential proxies for these modes.
- 🔤 **Search in Chinese** — Douyin is a Chinese platform. Use Chinese characters for best search results (e.g., `美食` for food, `娱乐` for entertainment, `时尚` for fashion)
- 📅 **Schedule trending runs** — set up a daily scheduled run to track how trending topics evolve over time
- 📊 **Combine modes** — run trending first to identify hot topics, then use search to find specific videos about those topics
- ⚡ **Start small** — test with `maxResults: 10` first to verify you're getting the right data before scaling up

### Integrations

**📊 Douyin Trends → Google Sheets**
Schedule daily trending runs and push results to a Google Sheets spreadsheet via Apify's integration. Track how hot values change day-over-day. Use the `word` and `hotValue` fields to build a trend tracker.

**📈 KOL Monitoring → Slack alerts**
Schedule weekly user profile scrapes for your top 20 Douyin KOL partners. Connect to Slack via Make or Zapier. Trigger alerts when follower counts spike >10% — perfect for spotting viral moments.

**🤖 Trend Data → AI Pipeline**
Use the Apify API to fetch trending topics programmatically. Feed the Chinese `word` field into a translation + sentiment analysis pipeline to power your China market intelligence dashboard.

**📧 Competitive Intelligence → Email Report**
Schedule weekly runs to scrape competitor brand keywords on Douyin. Export to CSV and email via Make to your marketing team every Monday morning.

### Using the Apify API

Run Douyin Analytics Scraper programmatically using any HTTP client.

#### Node.js

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

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

const run = await client.actor('automation-lab/douyin-analytics-scraper').call({
    mode: 'trending',
    maxResults: 50,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/douyin-analytics-scraper").call(run_input={
    "mode": "trending",
    "maxResults": 50,
})

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

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~douyin-analytics-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "trending", "maxResults": 50}'
```

### Use with AI agents via MCP

Douyin Analytics Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/douyin-analytics-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/douyin-analytics-scraper"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/douyin-analytics-scraper to get today's top 30 trending topics on Douyin and translate the Chinese terms to English"
- "Search Douyin for videos about '美食' (food) and find the top 10 creators by follower count"
- "Track how the Douyin hot search rankings change over the next week — scrape trending topics daily and summarize the shifts"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape Douyin?

This actor only accesses **publicly available data** from Douyin — the same information visible to any visitor without logging in. It does not access private accounts, private messages, or any data behind authentication.

Douyin's trending topics and public search results are openly available for viewing. We recommend:

- Using scraped data for research, analytics, and monitoring purposes
- Complying with applicable privacy laws (GDPR, CCPA, China's PIPL) when storing personal data
- Not using data for spam, harassment, or other harmful purposes
- Reviewing [Douyin's Terms of Service](https://www.douyin.com/about/policy) for platform-specific rules

Apify platform handles all data collection ethically: rate limiting, respectful request patterns, and no circumvention of authentication systems.

### FAQ

**How fast does it return results?**
Trending mode returns 47–52 topics in under 10 seconds — it uses a direct HTTP API call with no browser overhead. Search and user profile modes take 30–90 seconds per item due to Playwright browser rendering.

**Why do I need a proxy for search and profile modes?**
Douyin uses advanced bot detection (byted\_acrawler) that blocks datacenter IP addresses. Residential proxies from real user devices bypass this protection. The actor automatically configures residential proxies for search and profile modes.

**How is this different from TikTok scrapers?**
Douyin and TikTok are operated by separate entities for separate markets. Douyin (Chinese market) has different content, trending topics, creators, and API endpoints than TikTok (international market). If you need international TikTok data, see our [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper).

**Can I search in English?**
Yes, but Douyin is primarily a Chinese platform. Most content is in Chinese. For best results, search in Chinese characters. You can use a translation service to convert English terms to Chinese before passing them to the scraper.

**Why do some search results show 0 for play count or likes?**
Douyin's search API returns different amounts of metadata depending on the query and account type. Some fields may be omitted from the API response for certain videos. This is expected behavior.

**Why did my search return 0 results?**
This can happen if residential proxies are not configured or if Douyin is temporarily blocking the IP. Try running again, or check that proxy settings are set to `RESIDENTIAL` in the actor input. Trending mode works without proxies and always returns results.

### Other social media scrapers

- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — Scrape TikTok profiles, videos, and posts
- [TikTok Search Scraper](https://apify.com/automation-lab/tiktok-search-scraper) — Search TikTok by keyword
- [TikTok Comments Scraper](https://apify.com/automation-lab/tiktok-comments-scraper) — Extract comments from TikTok videos
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) — Scrape Instagram profiles and posts
- [YouTube Comments Scraper](https://apify.com/automation-lab/youtube-comments-scraper) — Extract comments from YouTube videos

# Actor input Schema

## `mode` (type: `string`):

Choose what to scrape: trending hot search topics, search results by keyword, or user profile analytics.

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

Keywords to search on Douyin (Chinese text supported). Each keyword runs a separate search. Only used in 'Search' mode.

## `searchType` (type: `string`):

Type of search results: videos or user accounts. Only used in 'Search' mode.

## `userUrls` (type: `array`):

List of Douyin user profile URLs (e.g. https://www.douyin.com/user/MS4wLjAB...) or short IDs. Only used in 'User Profile' mode.

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

Maximum number of results to extract. For trending mode, this limits how many top topics to return (max 50).

## `proxy` (type: `object`):

Proxy settings. Residential proxies are recommended for search and user profile modes. Trending mode works without proxies.

## Actor input object example

```json
{
  "mode": "trending",
  "keywords": [
    "美食"
  ],
  "searchType": "video",
  "userUrls": [],
  "maxResults": 20
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "trending",
    "keywords": [
        "美食"
    ],
    "searchType": "video",
    "userUrls": [],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/douyin-analytics-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 = {
    "mode": "trending",
    "keywords": ["美食"],
    "searchType": "video",
    "userUrls": [],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/douyin-analytics-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 '{
  "mode": "trending",
  "keywords": [
    "美食"
  ],
  "searchType": "video",
  "userUrls": [],
  "maxResults": 20
}' |
apify call automation-lab/douyin-analytics-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Douyin Analytics Scraper",
        "description": "Extract Douyin trending hot search topics, video search results, and user profile analytics. Get real-time rankings, engagement metrics, and follower counts. No login or API key required.",
        "version": "0.1",
        "x-build-id": "lbadEcMO5aMyg464k"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~douyin-analytics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-douyin-analytics-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/automation-lab~douyin-analytics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-douyin-analytics-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/automation-lab~douyin-analytics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-douyin-analytics-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scraping Mode",
                        "enum": [
                            "trending",
                            "search",
                            "userProfile"
                        ],
                        "type": "string",
                        "description": "Choose what to scrape: trending hot search topics, search results by keyword, or user profile analytics.",
                        "default": "trending"
                    },
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search on Douyin (Chinese text supported). Each keyword runs a separate search. Only used in 'Search' mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Search Type",
                        "enum": [
                            "video",
                            "user"
                        ],
                        "type": "string",
                        "description": "Type of search results: videos or user accounts. Only used in 'Search' mode.",
                        "default": "video"
                    },
                    "userUrls": {
                        "title": "Douyin User URLs or IDs",
                        "type": "array",
                        "description": "List of Douyin user profile URLs (e.g. https://www.douyin.com/user/MS4wLjAB...) or short IDs. Only used in 'User Profile' mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of results to extract. For trending mode, this limits how many top topics to return (max 50).",
                        "default": 30
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended for search and user profile modes. Trending mode works without proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
