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.

{
  "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.

{
  "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.

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'

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);

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:

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

{
  "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. This Actor instead returns creator profile cards from a known roster.