# Bilibili Scraper - Videos, Trending, Comments & Creator Leads (`scrapesage/bilibili-scraper`) Actor

Scrape Bilibili videos by keyword, trending feeds and partition leaderboards, full comment threads, and creator (UP) profiles with follower reach, extracted business contacts and lead scores. Pure HTTP, no login and no browser.

- **URL**: https://apify.com/scrapesage/bilibili-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Videos, Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 video scrapeds

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Bilibili Scraper - Videos, Trending, Comments & Creator Leads

Scrape **Bilibili (哔哩哔哩)** — China's largest video community, ~340M monthly users — without a login, a browser or a cookie. Search videos by keyword, pull the trending feeds and partition leaderboards, read full comment threads, and profile creators (**UP主**) with follower reach, extracted business contacts and a 0-100 lead score.

Runs on plain HTTP against Bilibili's own web API. No headless browser, so a video costs about a third of a second and a run **cannot** stall into the timeouts that plague browser-based scrapers.

---

### What you get

**One mode = one record type**, so every CSV / Excel export has clean, full columns instead of the blank-cell mess you get when a scraper mixes shapes in one dataset.

| Mode | Produces | Use it for |
|---|---|---|
| **Video search** | `video` rows | Find every video for a keyword, with filters for sort order, length, partition and publish date |
| **Trending & rankings** | `video` rows | Popular now (综合热门), partition leaderboards (排行榜), must-watch (入站必刷) |
| **Specific videos** | `video` rows | Full detail for URLs, BV IDs, av IDs or b23.tv share links |
| **Creators (UP主)** | `creator` rows | Influencer discovery, contact extraction and lead scoring |
| **Comments** | `comment` rows | Audience research, sentiment mining, community analysis |

#### Video rows (60+ fields, all populated)

Title, description, cover, duration, publish time, partition and parent category, and the **complete** Bilibili stat block — views, danmaku (弹幕), comments, favourites, **coins**, shares and likes — plus computed `engagementRate`, `likeRate`, `coinRate` and `favoriteRate`. Also resolution, episode/part list, credited collaborators, copyright status, paid-promotion flags, real tag objects, and the **uploader's follower count, upload count, total likes, bio, verification and extracted contact** on every single row.

> Bilibili's search endpoint returns a deliberately reduced record. This scraper hydrates every row from the full video API, so you get coins, shares, resolution, parts, collaborators and uploader stats that keyword-only scrapers leave blank.

#### Creator rows — the lead-gen wedge

Chinese creators publish their partnership contact **in their bio**: `商务合作请联系邮箱：bd@ysjf.com`, `商务：STN_7349`, `商务合作VX：yhtshe`. This scraper parses all of those patterns — e-mail, WeChat, QQ, Weibo, phone and bare business handles — and scores each creator 0-100 on contactability, reach, recency and verification.

Measured on real trending creators: **~40% expose a reachable business contact.** Every creator also carries followers, following, total likes received, per-type upload counts, verification, badge, and their recent uploads with average / peak reach.

#### Comment rows

Text, likes, reply count, pinned and uploader-reply flags, nested sub-replies, and the full author profile (UID, name, level, gender, bio, VIP and verification).

---

### Quick start

```jsonc
// Every video about a keyword, richest form
{ "mode": "search", "keywords": ["Minecraft", "原神"], "maxItems": 500 }

// What is trending in Tech and Gaming right now
{ "mode": "trending", "trendingSource": "ranking", "rankingPartitions": ["36", "4"] }

// Find food creators over 100k followers and pull their contacts
{ "mode": "creators", "creatorKeywords": ["美食"], "minFollowers": 100000, "maxItems": 200 }

// Read a video's comment thread
{ "mode": "comments", "videoUrls": ["https://www.bilibili.com/video/BV1uv411q7Mv"], "maxCommentsPerVideo": 500 }
````

Run it with no input at all and it returns a real sample from Bilibili trending — it never fails on empty input.

***

### Notes on coverage (measured, not claimed)

- **`publishLocation`** (the province an upload was posted from) is returned by Bilibili only on its list feeds. It is populated in **Trending & rankings**, and is genuinely absent from the search and single-video APIs — verified across three endpoint variants. It is left as an honest `null` rather than faked.
- **Keyword search caps at ~1,000 results per sort order.** Leave *Search all sort orders* on and the scraper walks every order and de-duplicates by video ID, reaching several thousand unique videos per keyword.
- **Comments and search are anonymous.** Nothing here needs your Bilibili account, so there is no session to expire and no cookie to babysit.
- A creator's own upload list is the one risk-controlled endpoint Bilibili exposes; the scraper retries it across IPs and falls back to a second verified endpoint, so `recentVideos` stays populated either way.

### Output views

Three built-in dataset views — **Videos**, **Creator leads** and **Comments** — so the export you download is already shaped for the job.

### Use with AI assistants (MCP)

This actor works as a tool for AI assistants through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Point your agent at it and ask for Bilibili videos, trending rankings, comment threads or creator leads in natural language.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### Pricing

Pay-per-event, so you pay for results and nothing else:

| Event | Price |
|---|---|
| Video scraped | $0.004 |
| Creator lead | $0.008 |
| Comment scraped | $0.001 |

A run that is throttled or matches nothing ends successfully with a status message and **charges you nothing**.

### Legal

Collects only publicly available data. You are responsible for using the output in line with Bilibili's terms and applicable law, including data-protection rules where personal data is involved.

# Actor input Schema

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

One mode per run, and one record type per mode - so the CSV/Excel export always has clean columns. Video search, Trending & rankings and Specific videos all produce VIDEO rows. Creators produces CREATOR rows (with contact extraction and a lead score). Comments produces COMMENT rows.

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

Keywords to search Bilibili for. Chinese and English both work (e.g. 美食, Minecraft, iPhone). Bilibili caps one keyword+sort combination at about 1,000 results; leave 'Search all sort orders' on and the scraper cycles the sort orders and de-duplicates to push past that ceiling. Used by the Video search mode.

## `searchOrder` (type: `string`):

Which Bilibili sort order to start from.

## `deepSearch` (type: `boolean`):

Bilibili returns at most ~1,000 results per keyword per sort order. With this on, the scraper walks every sort order for each keyword and de-duplicates by video ID, which reaches several thousand unique videos per keyword instead of one thousand.

## `searchDuration` (type: `string`):

Only return videos in this length band.

## `searchPartitionId` (type: `integer`):

Optional Bilibili partition/category ID, e.g. 4 = Gaming, 36 = Tech, 211 = Food, 160 = Life, 3 = Music, 129 = Dance, 188 = Digital, 234 = Sports, 223 = Cars, 155 = Fashion, 5 = Entertainment, 181 = Film & TV, 119 = Kichiku, 1 = Anime. Leave empty to search every partition.

## `publishedWithinDays` (type: `integer`):

Only return videos published in this window, e.g. 7 for the last week. Leave at 0 for no date filter.

## `trendingSource` (type: `string`):

Which of Bilibili's own discovery feeds to pull.

## `rankingPartitions` (type: `array`):

Partition IDs to pull leaderboards for, when Trending source = Leaderboard. 0 = All, 1 = Anime, 3 = Music, 4 = Gaming, 5 = Entertainment, 36 = Tech, 119 = Kichiku, 129 = Dance, 155 = Fashion, 160 = Life, 181 = Film & TV, 188 = Digital, 217 = Animals, 223 = Cars, 234 = Sports.

## `videoUrls` (type: `array`):

Bilibili videos to scrape in full detail, or to pull comments for. Accepts a full URL (https://www.bilibili.com/video/BV1uv411q7Mv), a b23.tv share link, a bare BV ID (BV1uv411q7Mv) or an av ID (av243922477). Used by the Specific videos and Comments modes.

## `commentSort` (type: `string`):

How to order comments in the Comments mode.

## `maxCommentsPerVideo` (type: `integer`):

How deep to page each video's comment thread. Each top-level comment carries its own nested sub-replies.

## `creatorUrls` (type: `array`):

Creators to scrape. Accepts a space URL (https://space.bilibili.com/946974) or a bare numeric UID (946974). Used by the Creators mode.

## `creatorKeywords` (type: `array`):

Search Bilibili's creator directory instead of supplying UIDs, e.g. 美食 (food), 数码 (tech), 健身 (fitness). Every match is enriched into a full creator record with follower counts and extracted contacts.

## `minFollowers` (type: `integer`):

Skip creators below this follower count. Applied to the search result before enrichment, so it also saves requests.

## `includeCreatorVideos` (type: `boolean`):

Nest the creator's latest videos into the record and compute average/median reach from them. Adds one request per creator.

## `maxCreatorVideos` (type: `integer`):

How many of the creator's latest videos to nest into the record.

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

Stop after this many records (videos, creators or comments depending on the mode). Set to 0 for no limit - the run then stops safely on its own time budget rather than timing out.

## `fullVideoDetail` (type: `boolean`):

Bilibili's search endpoint returns a reduced record. With this on, every video is hydrated from the full video API, which adds coins, shares, resolution, the episode/part list, collaborators, copyright status, the complete description, real tag objects AND the uploader's follower count, upload count, total likes, bio and verification - all in one extra request per video. Turn it off for a faster, lighter run that returns only the search-result fields.

## `includeTopComments` (type: `integer`):

Nest this many top comments inside each video row (0 = off). Use the Comments mode instead if you want one row per comment.

## `maxConcurrency` (type: `integer`):

How many enrichment requests to keep in flight. The default is tuned for Bilibili's rate limits; lower it if a very large run starts getting throttled.

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

Politeness delay applied between request starts. The default is tuned for Bilibili's rate limits; raise it if you see throttling on very large runs.

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

Apify Proxy is used by default. The scraper runs on the cheap datacenter lane and automatically escalates only the risk-controlled endpoints to residential, so most runs cost very little proxy traffic.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "Minecraft"
  ],
  "searchOrder": "totalrank",
  "deepSearch": true,
  "searchDuration": "0",
  "publishedWithinDays": 0,
  "trendingSource": "popular",
  "rankingPartitions": [
    "0"
  ],
  "commentSort": "hot",
  "maxCommentsPerVideo": 50,
  "minFollowers": 0,
  "includeCreatorVideos": true,
  "maxCreatorVideos": 12,
  "maxItems": 50,
  "fullVideoDetail": true,
  "includeTopComments": 0,
  "maxConcurrency": 5,
  "requestDelayMs": 250,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `videos` (type: `string`):

All scraped records for the run.

## `creatorLeads` (type: `string`):

Creators with follower reach, extracted business contacts and a lead score.

## `comments` (type: `string`):

Comment threads with author, likes and reply counts.

# 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": "search",
    "keywords": [
        "Minecraft"
    ],
    "searchOrder": "totalrank",
    "deepSearch": true,
    "trendingSource": "popular",
    "maxItems": 50,
    "fullVideoDetail": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/bilibili-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": "search",
    "keywords": ["Minecraft"],
    "searchOrder": "totalrank",
    "deepSearch": True,
    "trendingSource": "popular",
    "maxItems": 50,
    "fullVideoDetail": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/bilibili-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": "search",
  "keywords": [
    "Minecraft"
  ],
  "searchOrder": "totalrank",
  "deepSearch": true,
  "trendingSource": "popular",
  "maxItems": 50,
  "fullVideoDetail": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/bilibili-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bilibili Scraper - Videos, Trending, Comments & Creator Leads",
        "description": "Scrape Bilibili videos by keyword, trending feeds and partition leaderboards, full comment threads, and creator (UP) profiles with follower reach, extracted business contacts and lead scores. Pure HTTP, no login and no browser.",
        "version": "0.1",
        "x-build-id": "Z5MLm3MhW4f4R5kMq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~bilibili-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-bilibili-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/scrapesage~bilibili-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-bilibili-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/scrapesage~bilibili-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-bilibili-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "search",
                            "trending",
                            "videos",
                            "creators",
                            "comments"
                        ],
                        "type": "string",
                        "description": "One mode per run, and one record type per mode - so the CSV/Excel export always has clean columns. Video search, Trending & rankings and Specific videos all produce VIDEO rows. Creators produces CREATOR rows (with contact extraction and a lead score). Comments produces COMMENT rows.",
                        "default": "search"
                    },
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search Bilibili for. Chinese and English both work (e.g. 美食, Minecraft, iPhone). Bilibili caps one keyword+sort combination at about 1,000 results; leave 'Search all sort orders' on and the scraper cycles the sort orders and de-duplicates to push past that ceiling. Used by the Video search mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchOrder": {
                        "title": "Sort results by",
                        "enum": [
                            "totalrank",
                            "click",
                            "pubdate",
                            "dm",
                            "stow",
                            "scores"
                        ],
                        "type": "string",
                        "description": "Which Bilibili sort order to start from.",
                        "default": "totalrank"
                    },
                    "deepSearch": {
                        "title": "Search all sort orders (recommended)",
                        "type": "boolean",
                        "description": "Bilibili returns at most ~1,000 results per keyword per sort order. With this on, the scraper walks every sort order for each keyword and de-duplicates by video ID, which reaches several thousand unique videos per keyword instead of one thousand.",
                        "default": true
                    },
                    "searchDuration": {
                        "title": "Duration filter",
                        "enum": [
                            "0",
                            "1",
                            "2",
                            "3",
                            "4"
                        ],
                        "type": "string",
                        "description": "Only return videos in this length band.",
                        "default": "0"
                    },
                    "searchPartitionId": {
                        "title": "Limit to a partition (分区) ID",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional Bilibili partition/category ID, e.g. 4 = Gaming, 36 = Tech, 211 = Food, 160 = Life, 3 = Music, 129 = Dance, 188 = Digital, 234 = Sports, 223 = Cars, 155 = Fashion, 5 = Entertainment, 181 = Film & TV, 119 = Kichiku, 1 = Anime. Leave empty to search every partition."
                    },
                    "publishedWithinDays": {
                        "title": "Published within the last N days",
                        "minimum": 0,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only return videos published in this window, e.g. 7 for the last week. Leave at 0 for no date filter.",
                        "default": 0
                    },
                    "trendingSource": {
                        "title": "Trending source",
                        "enum": [
                            "popular",
                            "ranking",
                            "precious"
                        ],
                        "type": "string",
                        "description": "Which of Bilibili's own discovery feeds to pull.",
                        "default": "popular"
                    },
                    "rankingPartitions": {
                        "title": "Leaderboard partitions",
                        "type": "array",
                        "description": "Partition IDs to pull leaderboards for, when Trending source = Leaderboard. 0 = All, 1 = Anime, 3 = Music, 4 = Gaming, 5 = Entertainment, 36 = Tech, 119 = Kichiku, 129 = Dance, 155 = Fashion, 160 = Life, 181 = Film & TV, 188 = Digital, 217 = Animals, 223 = Cars, 234 = Sports.",
                        "default": [
                            "0"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "videoUrls": {
                        "title": "Video URLs or IDs",
                        "type": "array",
                        "description": "Bilibili videos to scrape in full detail, or to pull comments for. Accepts a full URL (https://www.bilibili.com/video/BV1uv411q7Mv), a b23.tv share link, a bare BV ID (BV1uv411q7Mv) or an av ID (av243922477). Used by the Specific videos and Comments modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "commentSort": {
                        "title": "Comment order",
                        "enum": [
                            "hot",
                            "time"
                        ],
                        "type": "string",
                        "description": "How to order comments in the Comments mode.",
                        "default": "hot"
                    },
                    "maxCommentsPerVideo": {
                        "title": "Max comments per video",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How deep to page each video's comment thread. Each top-level comment carries its own nested sub-replies.",
                        "default": 50
                    },
                    "creatorUrls": {
                        "title": "Creator profiles (UP主)",
                        "type": "array",
                        "description": "Creators to scrape. Accepts a space URL (https://space.bilibili.com/946974) or a bare numeric UID (946974). Used by the Creators mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "creatorKeywords": {
                        "title": "Find creators by keyword",
                        "type": "array",
                        "description": "Search Bilibili's creator directory instead of supplying UIDs, e.g. 美食 (food), 数码 (tech), 健身 (fitness). Every match is enriched into a full creator record with follower counts and extracted contacts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minFollowers": {
                        "title": "Minimum followers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip creators below this follower count. Applied to the search result before enrichment, so it also saves requests.",
                        "default": 0
                    },
                    "includeCreatorVideos": {
                        "title": "Include the creator's recent uploads",
                        "type": "boolean",
                        "description": "Nest the creator's latest videos into the record and compute average/median reach from them. Adds one request per creator.",
                        "default": true
                    },
                    "maxCreatorVideos": {
                        "title": "Recent uploads per creator",
                        "minimum": 0,
                        "maximum": 300,
                        "type": "integer",
                        "description": "How many of the creator's latest videos to nest into the record.",
                        "default": 12
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many records (videos, creators or comments depending on the mode). Set to 0 for no limit - the run then stops safely on its own time budget rather than timing out.",
                        "default": 100
                    },
                    "fullVideoDetail": {
                        "title": "Fetch the complete video record (recommended)",
                        "type": "boolean",
                        "description": "Bilibili's search endpoint returns a reduced record. With this on, every video is hydrated from the full video API, which adds coins, shares, resolution, the episode/part list, collaborators, copyright status, the complete description, real tag objects AND the uploader's follower count, upload count, total likes, bio and verification - all in one extra request per video. Turn it off for a faster, lighter run that returns only the search-result fields.",
                        "default": true
                    },
                    "includeTopComments": {
                        "title": "Top comments to nest per video",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Nest this many top comments inside each video row (0 = off). Use the Comments mode instead if you want one row per comment.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Parallel requests",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many enrichment requests to keep in flight. The default is tuned for Bilibili's rate limits; lower it if a very large run starts getting throttled.",
                        "default": 5
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Politeness delay applied between request starts. The default is tuned for Bilibili's rate limits; raise it if you see throttling on very large runs.",
                        "default": 250
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify Proxy is used by default. The scraper runs on the cheap datacenter lane and automatically escalates only the risk-controlled endpoints to residential, so most runs cost very little proxy traffic.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
