# Bilibili Creator Upload Video Samples (`automation-lab/bilibili-creator-upload-videos`) Actor

Resolve creator numeric mids and export matching-uploader Bilibili videos from bounded public search samples, with titles, timestamps, observed play and danmaku counts. Not a complete latest-upload feed or channel archive.

- **URL**: https://apify.com/automation-lab/bilibili-creator-upload-videos.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Videos, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.28 / 1,000 creator video samples

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Bilibili Creator Upload Video Samples

Extract **bilibili creator videos** from selected numeric creator mids for repeat campaign and content research. This Actor resolves each public creator name, searches bounded newest-first and relevance pages, and exports only genuine videos whose uploader mid exactly matches your input.

**This is a search-derived sample, not a complete latest-upload feed or channel archive.** It needs no buyer login cookies, downloads no media, and does not fetch comment or danmaku text.

### Who is it for?

Campaign analysts comparing videos attributed to a known creator, researchers collecting public video metadata, and teams maintaining repeat observations in a spreadsheet or warehouse. Keep your own history keyed by creatorMid and bvid to compare observations over time.

### Why use it?

Searching a creator name manually often finds mentions, reposts, or unrelated accounts. Exact numeric uploader matching excludes those candidates. Every record identifies its search order and page so you can distinguish newest-first discoveries from relevance fallback. Global and per-creator limits keep collection bounded without pretending to deliver an entire channel.

### How it works

1. Validate numeric mid strings and deduplicate them in input order.
2. Resolve a public name for each mid.
3. Inspect up to `searchPages` newest-first search pages, each containing up to 20 candidates.
4. If accepted caps remain unfilled, inspect relevance pages with the same bound.
5. Keep only video-type records with a valid BV ID and exact uploader mid; deduplicate BV IDs for that creator.
6. Save accepted videos to the default dataset and a per-creator sampling summary to `SUMMARY` in the key-value store.

Search ranking and indexing change. A relevance sample may contain older videos. Newest-first refers to upstream candidate ordering, not a guarantee that all of a creator's newest uploads are indexed or present. Missing matches do not imply no uploads exist.

### Getting started

1. Find the numeric mid in a public creator profile URL, such as `space.bilibili.com/546195`.
2. Enter that numeric portion as a string in `creatorMids`.
3. Leave the default limits for a small bounded sample.
4. Run the Actor, inspect both the videos and sampling summary, then export JSON or CSV from the dataset.

```json
{"creatorMids":["546195"],"maxItems":20,"maxVideosPerCreator":20,"searchPages":1}
```

### Input parameters

| Parameter | Default | Meaning |
|---|---:|---|
| creatorMids | required | 1–10 positive numeric mid strings; not names, URLs or numeric JSON values |
| maxItems | 20 | Global cap of 1–100 accepted unique videos |
| maxVideosPerCreator | 20 | Per-creator cap of 1–20 accepted videos |
| searchPages | 1 | 1–3 pages per search order per creator; at most 40 candidates by default, 120 at maximum |

Earlier creators can consume the global cap before later creators are visited. Both caps apply after uploader filtering and deduplication. A short search page ends that order. Zero, fractional limits, unknown fields, and cookies are rejected; there is no unlimited mode. Public source restrictions and billing/runtime limits can yield fewer rows than requested.

### Output fields

| Field | Meaning |
|---|---|
| creatorMid, creatorName | Requested exact uploader identity and publicly resolved name |
| bvid, videoUrl | Genuine video identity and canonical HTTPS URL |
| title | Search title without HTML highlight tags |
| publishedAt | UTC source publication timestamp, or null |
| playCount | Observed search play count, potentially rounded by the source, or null |
| danmakuCount | Observed bullet-comment count, not text, or null |
| searchOrder | `pubdate` for newest-first or `totalrank` for relevance |
| searchPage | One-based page in that order |
| sampledAt | UTC observation timestamp |
| coverage | Explicit bounded-search disclaimer |

### Example output

A local sample returned this public video (counts are an observation, not live promises):

```json
{
  "creatorMid":"546195",
  "creatorName":"老番茄",
  "bvid":"BV1iqpt6cEMU",
  "videoUrl":"https://www.bilibili.com/video/BV1iqpt6cEMU",
  "title":"超市里……未检测到人脸……",
  "publishedAt":"2026-10-10T06:30:00.000Z",
  "playCount":1414058,
  "danmakuCount":7906,
  "searchOrder":"pubdate",
  "searchPage":1,
  "sampledAt":"2026-10-11T06:06:09.142Z",
  "coverage":"Bounded search sample; not complete latest uploads or archive"
}
```

### How much does it cost to sample Bilibili creator videos?

Pay per event: a **$0.001 start fee** once per valid run, plus each saved unique video. No separate charge for creator resolution, search candidates, duplicates, the summary, or danmaku counts. Source errors can leave partial charged output; nonexistent creators or an empty matching sample still incur the start fee. Invalid input fails before charging.

| Plan tier | Per video |
|---|---:|
| FREE | $0.00437 |
| BRONZE | $0.0038 |
| SILVER | $0.002964 |
| GOLD / PLATINUM / DIAMOND | $0.00228 |

At BRONZE, 1 video costs $0.0048, 10 videos $0.039, 20 videos $0.077, and 100 videos $0.381, including one start fee. The 100-video example requires several creators and sufficient matching candidates; it is not a promise of coverage. Check the active pricing tab before running. Set an Apify maximum charge to control spend.

### Limits and failure behavior

No complete upload list, date filter, channel archive, real-time alerts, followers, private videos, comment threads, danmaku text, or media downloads are supplied. This targets bilibili.com, not Bilibili Global. No customer account or login cookie is accepted.

Requests are sequential, with bounded retries for temporary network, HTTP 429 and server errors. Search can use an alternate public endpoint when its primary endpoint is blocked. No paid residential fallback is enabled. Exhausted source errors, invalid shapes and risk-control vouchers fail rather than masquerading as empty success. Existing rows in a failed run are partial.

The summary distinguishes `not_found` from `no_matching_videos_in_sample`; it also records billing-limit termination. Only visited creators appear there. A successful empty sample means no exact matches were observed within its bounds, not that the channel is empty.

### Integrations

Schedule repeat samples in Apify, then join by `(creatorMid,bvid)` in your warehouse. Track `sampledAt` for each play/danmaku observation instead of overwriting history. Export CSV for campaign comparison or JSON for an ETL pipeline. Send datasets through Make, Zapier or webhooks only after checking terminal run status; keep partial failures labelled.

### API usage

Start one run and retain its ID and storage IDs. Poll that same run to completion before exporting results.

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~bilibili-creator-upload-videos/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' \
  -d '{"creatorMids":["546195"],"maxItems":5}'
```

JavaScript with `apify-client`:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bilibili-creator-upload-videos')
  .call({ creatorMids: ['546195'], maxItems: 5 });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 20 });
```

Python with `apify-client`:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bilibili-creator-upload-videos').call(
    run_input={'creatorMids': ['546195'], 'maxItems': 5})
items = client.dataset(run['defaultDatasetId']).list_items(limit=20).items
```

### MCP setup

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/bilibili-creator-upload-videos"
```

Equivalent Claude Desktop, Cursor and VS Code client configuration:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/bilibili-creator-upload-videos"}}}
```

Example prompt: “Sample up to five videos attributed to Bilibili creator mid 546195. Show observed counts and explain sample coverage.”

Discover actual tool names and schemas with scoped `tools/list`; Actor selection also adds run/data/storage/abort tools, not exactly one tool. Discovery is read-only and does not authorize execution. For an authorized invocation, start once; keep its run ID/status/storage IDs. If nonterminal, follow that same run with bounded 2/4/8-second backoff capped at 10 seconds and a 120-second deadline. `call-actor` waits at most 45 seconds; configure transport timeout above the selected wait plus margin. On timeout, recover the known run rather than restart. At deadline report pending and stop; failed output is partial.

After success read untransformed dataset JSON in pages of 20 source rows, starting offset 0, at most 100 rows or 64 KiB admitted to model context. Enforce bytes host-side before injection, summarize oversized rows with disclosure, and track source offsets rather than transformed counts. If the client cannot intercept oversized responses, do not claim a hard byte guarantee. Report returned rows, continuation offset and truncation. Full exports belong in storage. These are consumer context budgets, not Actor collection limits or numeric token-saving promises.

### Legality, responsible use and privacy

Collect public metadata responsibly, respect applicable source terms and laws, and avoid using samples to infer private behavior or guaranteed campaign reach. Public availability is not legal advice or permission to redistribute copyrighted media. The Actor downloads no video files.

This independent tool is not affiliated with or endorsed by Bilibili. It uses no AI model during execution. Bilibili public APIs receive requested creator identities and search names; Apify stores output under your account retention settings. Delete datasets, key-value stores and logs in Apify when no longer needed; this Actor creates no cross-run cache. For help, open an Actor issue with a run link and safe reproduction input; never post login cookies or tokens.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days.

### FAQ and troubleshooting

**Why are uploads missing?** Search is not a channel listing. Name changes, index delays, ranking, mentions and page bounds can omit uploads. Increasing `searchPages` may find more, but never guarantees completeness.

**Why is an old video present?** Relevance fallback can return older matching-uploader videos; inspect `searchOrder` and `publishedAt`.

**Why did a run fail?** Source risk controls or transient network errors can exhaust bounded routes. Check logs and treat existing rows as partial. Do not blindly relaunch a failed run repeatedly.

**Can I pass a profile URL or cookie?** No. Extract the numeric mid yourself; input accepts public mids only and rejects unsupported fields.

### Related Actors

For known video URLs and keyword search with optional comments, see [Bilibili Scraper](https://apify.com/automation-lab/bilibili-scraper). It serves a different discovery input; this Actor specializes in resolved-name sampling with strict mid attribution.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/bilibili-creator-upload-videos/changelog.md

# Actor input Schema

## `creatorMids` (type: `array`):

1–10 positive numeric mid strings, not names or profile URLs. Duplicate mids are processed once, in first-occurrence input order. Each name is resolved publicly before searching; uploader mid must match exactly.

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

Global accepted unique-video cap (1–100; default 20). Creators are processed in input order, so earlier creators can consume the cap. Stops discovery when reached. Zero is invalid; the cap does not guarantee that many matches.

## `maxVideosPerCreator` (type: `integer`):

Per-creator cap after exact-mid filtering and BV-ID deduplication across both search orders (1–20; default 20). Also bounded by maxItems. Fewer matches are normal and not proof the creator has no uploads.

## `searchPages` (type: `integer`):

Inspect at most 1–3 pages of 20 search candidates for each creator in newest-first order, then relevance fallback if the accepted caps remain unfilled. Default 1; at most 40 candidates per creator by default. Short pages stop that order. This bounds search coverage, not a complete channel listing.

## Actor input object example

```json
{
  "creatorMids": [
    "546195"
  ],
  "maxItems": 20,
  "maxVideosPerCreator": 20,
  "searchPages": 1
}
```

# Actor output Schema

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

Accepted genuine videos, not complete uploads.

## `summary` (type: `string`):

Visited creator counts, not-found/no-matching-sample states and billing-limit flag.

# 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 = {
    "creatorMids": [
        "546195"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bilibili-creator-upload-videos").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 = { "creatorMids": ["546195"] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bilibili-creator-upload-videos").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "creatorMids": [
    "546195"
  ]
}' |
apify call automation-lab/bilibili-creator-upload-videos --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/bilibili-creator-upload-videos"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/otBnpE90robRSRvNc/builds/rvn9eRh1jNioYddvA/openapi.json