# Bilibili Creator Profiles Scraper (`automation-lab/bilibili-creator-profile-records`) Actor

Export public Bilibili creator profiles from numeric mids or profile URLs, including bio, follower and following counts, likes, level and verification for KOL roster enrichment.

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

## Pricing

from $1.92 / 1,000 item extracteds

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 Profiles Scraper

Export public **Bilibili creator profiles** from a supplied roster of numeric mids or profile URLs. Each row includes bio, followers, following, aggregate likes, account level and official verification details. Use successive snapshots to enrich a KOL roster and compare public profile changes in your own spreadsheet or pipeline.

No Bilibili login cookies are required. This Actor fetches profile cards, not videos or a discovered influencer list.

### Who is it for?

- China-market research teams maintaining a known creator roster.
- Influencer agencies checking follower counts and public verification descriptions.
- Analysts joining creator snapshots to campaign data by stable numeric mid.

### Why use it?

You provide the creators you care about, rather than receiving unrelated keyword-search videos. Numeric IDs and profile URLs resolve to the same canonical profile identity. Duplicate creators are removed before the run limit, so repeated URLs do not create duplicate profile charges.

The output has a collection timestamp on every row. It does not calculate growth, store a profile history, generate alerts or prove an account's identity. Those are downstream responsibilities.

### Getting started

1. Open the Input tab and enter numeric mids as strings, such as `546195`, or `https://space.bilibili.com/208259`.
2. Set the maximum number of unique profiles to process.
3. Run the Actor and inspect the run status before using results.
4. Open the default dataset and export JSON, CSV or Excel using Apify's dataset tools.

```json
{
  "creators": ["546195", "https://space.bilibili.com/208259"],
  "maxItems": 10
}
```

### Input parameters

| Parameter | Meaning |
| --- | --- |
| `creators` | Required array of 1–1000 strings: positive numeric mids or public `space.bilibili.com` profile URLs. |
| `maxItems` | Global unique-profile limit, default 10, allowed 1–1000. Zero is not unlimited. |

Whitespace around entries and leading zeroes in numeric mids are removed. Profile URLs may end in `/video` or `/dynamic`; query strings do not affect identity. Video URLs, other hosts, URL credentials, other profile subpaths and unsupported input fields are rejected.

All entries are validated, including entries beyond the selected limit. Deduplication preserves first-seen order, then `maxItems` selects the first unique creators. A billing cap can end collection before the requested limit.

### Extracted data

| Field | Meaning |
| --- | --- |
| `mid` | Canonical creator ID as a string. |
| `profileUrl` | Canonical public profile URL. |
| `name` | Public display name. |
| `bio` | Public signature, including an empty string when the creator has no bio. |
| `avatarUrl` | Avatar URL; the Actor does not download the image. |
| `followers` | Profile-card follower count. |
| `following` | Profile-card following count. |
| `likes` | Aggregate likes reported by the public card, not likes on one video. |
| `level` | Current account level. |
| `verification` | Source type, description and a derived verified flag. Type -1 means unverified; nonnegative types mean the source marks verification. |
| `scrapedAt` | UTC collection timestamp, not profile-update time. |

### Output example

The following shape is based on a tested public profile card; identity, text and counts are anonymized. Counts change between runs.

```json
{
  "mid": "123456789",
  "profileUrl": "https://space.bilibili.com/123456789",
  "name": "Example Creator",
  "bio": "Example public bio",
  "avatarUrl": "https://i0.hdslb.com/example.jpg",
  "followers": 1000,
  "following": 20,
  "likes": 2500,
  "level": 6,
  "verification": {"type": -1, "description": "", "verified": false},
  "scrapedAt": "2026-10-07T12:00:00.000Z"
}
```

Required profile fields are validated before saving. A challenged or malformed response does not become a blank profile row. Output schemas allow nullable fields for platform compatibility, but this implementation fails when required source counts are missing.

### How much does it cost to extract Bilibili creator profiles?

The pricing model is pay per event: one run-start event and one item event per saved creator profile. Duplicate mids and failed lookups do not generate item events. A failed run may still contain earlier charged profile rows.

The run-start fee is **$0.00005**. Per saved profile: FREE $0.00368, BRONZE $0.0032, SILVER $0.002496, GOLD/PLATINUM/DIAMOND $0.00192. Spend tiers follow Apify's qualifying aggregate monthly Store spend, not a private volume schedule.

Worked example at BRONZE: one profile totals $0.00325, 25 profiles total $0.08005, and 100 profiles total $0.32005, including the start fee. These are event-price estimates, not guaranteed invoices. Review the Pricing tab for your tier and configure a maximum total charge. There are no separate proxy or data-source charges.

### Limits and failure behavior

This is a public profile-card snapshot, not a complete account archive. It does not extract uploads, posts, contact lists, private fields, danmaku or comments. Counts reflect the upstream public API's snapshot and may be cached or change during collection.

Requests are sequential, with a 300 ms pause between saved creators. The default run timeout is 1800 seconds (30 minutes), at 256 MiB. A small successful roster measured about 0.64 seconds per creator interval; extending that pacing to 1000 profiles projects about 11 minutes plus startup, not a measured 1000-profile throughput guarantee. The 30-minute default leaves room for slower responses without increasing concurrency or enabling paid fallback.

For large rosters, leave the 30-minute timeout in Run options (API callers can set `timeout=1800` on the runs endpoint). A saved Task or explicit API timeout can override the default: do not use a five-minute override for a 1000-profile roster. If responses slow down, use smaller roster batches or increase the run timeout deliberately. Retries and upstream availability can still prevent completion; check status and unique row count before treating a snapshot as complete. A timeout leaves any earlier rows partial and charged.

Network failures, HTTP 429 and server errors have at most three attempts. A source challenge, non-success API response, unknown creator or missing required field fails the run immediately; earlier dataset rows are partial results. Do not interpret a failed run as a complete roster.

There is no automatic paid-proxy fallback or browser mode. Availability depends on Bilibili allowing the public-card route from the execution environment. Supplying login cookies is not supported.

### Recurring roster comparisons

Use an Apify schedule to run the same roster periodically, then persist each successful dataset in your own storage. Join snapshots by `mid`, not display name. Compare follower counts and verification descriptions with a consistent interval and retain `scrapedAt` for auditability. The Actor does not itself send notifications or maintain historical state.

### Integrations

- Export a successful dataset to Google Sheets for KOL roster enrichment.
- Send dataset rows to a warehouse or database and join them to campaign IDs.
- Use Make or Zapier to retrieve the dataset after a successful run, then compute changes downstream.

Inspect run status before processing outputs; failed-run rows are incomplete even if the dataset is nonempty.

### API usage

Keep your Apify token in a secret environment variable. Start a run once and retain its run ID; poll that same run and retrieve its `defaultDatasetId` after success.

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

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bilibili-creator-profile-records')
    .call({ creators: ['546195'], maxItems: 1 });
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 20 });
console.log(items);
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bilibili-creator-profile-records').call(
    run_input={'creators': ['546195'], 'maxItems': 1})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(f"Run {run['id']}: {run['status']}")
print(client.dataset(run['defaultDatasetId']).list_items(limit=20).items)
```

### MCP setup for Claude Desktop, Cursor, and VS Code

Use the Actor-scoped hosted endpoint rather than an unqualified catalog. For Claude Code, use the command below. For Claude Desktop, Cursor, and VS Code, add the equivalent HTTP server entry in your client's MCP configuration, using the JSON example and your client's secure Apify authentication flow:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/bilibili-creator-profile-records'
```

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

Discover actual tool names and argument schemas with read-only `tools/list`. Actor selection also exposes run/data helpers; it is not exactly one tool. Example prompt: “Fetch public profile cards for mids 546195 and 208259; show their follower counts and verification descriptions.” Execution requires your authorization and an authenticated client.

Start once and retain the run and storage IDs; IDs are not dataset rows. A call may return before completion (`waitSecs` is at most 45 seconds). Follow the same run with bounded backoff, for example 2, 4, 8 then 10 seconds, up to a 120-second total deadline. Recover the known run after a client timeout rather than starting again; report pending at the deadline or failure honestly.

After success, read bounded dataset pages, for example 20 rows at a time from source offset 0, at most 100 rows and 64 KiB of serialized content admitted to model context. Process pages host-side to enforce byte limits, disclose truncation and record the next source offset. Keep complete exports outside model context. If your client cannot intercept oversized responses, do not claim a hard byte guarantee. No universal token savings are promised.

### Legality, responsible use and diagnostics

Use public information responsibly and follow applicable laws and source terms. Public availability does not grant unrestricted reuse, consent for outreach or permission to make sensitive inferences. Verification reflects the source's designation, not our endorsement.

This Actor uses no AI model for extraction or outputs and is not affiliated with Bilibili. Public creator identity, bio and engagement counts go to your run's dataset; the source receives requested public mids and request-network metadata. Actor storage and run logs follow your Apify account retention settings: delete datasets/runs when no longer needed. There is no cross-run private cache or extra history store. We do not log profile bodies or credentials.

For help, open an issue in the Actor's Apify Store Issues tab. Use only public inputs and avoid posting secrets. User-reported Store issues receive a substantive response within 14 calendar days.

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. Do not include private credentials in creator entries.

### FAQ and troubleshooting

**Can I search for new creators?** No. Supply known mids or profile URLs. This is roster enrichment, not keyword discovery.

**Why are there fewer rows than entries?** Duplicates are removed, `maxItems` caps unique profiles, and billing caps can stop collection. A failed run may have only partial rows.

**Why did a public profile fail?** The upstream service may reject requests, remove a creator or change the response shape. Check the run log and exact input; do not regard partial output as a complete roster.

**Can I get historical follower counts?** Not from a single run. Store scheduled snapshots yourself and compare them downstream.

### Related Actors

For video URLs, keyword video discovery and optional comment samples, use [Bilibili Scraper](https://apify.com/automation-lab/bilibili-scraper). This Actor instead returns creator profile cards from a known roster.

# Changelog

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

# Actor input Schema

## `creators` (type: `array`):

Supply 1–1000 positive numeric mid strings or public space.bilibili.com profile URLs. URLs may end in /video or /dynamic; query strings are ignored. No search, login cookies or video URLs. Duplicate mids are removed before maxItems, preserving first-seen order. All entries are validated even beyond the limit.

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

Global limit on unique supplied creators processed, after deduplication. Default 10, range 1–1000; zero is not unlimited. Fewer rows may be produced if billing limits stop the run. An unavailable creator or source challenge fails the run; earlier rows remain partial, not a complete roster.

## Actor input object example

```json
{
  "creators": [
    "546195",
    "https://space.bilibili.com/208259"
  ],
  "maxItems": 10
}
```

# Actor output Schema

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

Typed profile identities, bio, counts, level and official verification for successfully collected creators.

# 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 = {
    "creators": [
        "546195",
        "https://space.bilibili.com/208259"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bilibili-creator-profile-records").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 = { "creators": [
        "546195",
        "https://space.bilibili.com/208259",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bilibili-creator-profile-records").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 '{
  "creators": [
    "546195",
    "https://space.bilibili.com/208259"
  ]
}' |
apify call automation-lab/bilibili-creator-profile-records --silent --output-dataset

```

## MCP server setup

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

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/Phj48UwGdrF5bXTJn/builds/RsOaIdbjERHhUt7n5/openapi.json