# Douyin Creator Profiles Scraper (`automation-lab/douyin-creator-profiles`) Actor

Export supplied public Douyin creator profiles with identity, bio, followers, following, total likes, works count, avatar and public IP region for recurring benchmarking.

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

## Pricing

from $4.52 / 1,000 creator profiles

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

## Douyin Creator Profiles Scraper

Export **douyin creator profiles** from supplied public profile URLs for recurring creator benchmarking. Get identity, biography, exact public followers, following, total likes, works count, avatar URL and public IP region in timestamped snapshots.

This Actor collects **profiles only**. It does not collect recent posts, videos, comments, follower lists, search results, historical snapshots or private account data.

### Who is it for?

- Creator analysts maintaining a supplied shortlist of Douyin accounts.
- Campaign teams comparing public creator counters before and after a campaign.
- Researchers building their own longitudinal dataset through scheduled snapshots.

You supply the creators. The Actor does not discover or rank creators, calculate growth automatically, or infer audience demographics.

### Why use this Actor?

Each row represents one creator at one retrieval time, with stable IDs for joining your own snapshots. Exact numeric counters come from the browser's public profile response rather than rounded display text. Missing optional values stay null, not invented zeros.

Browser sessions are anonymous. You do not need to supply a Douyin password, cookies or API key. Access can still be blocked by Douyin; no universal availability is promised.

### Getting started

1. Open a public creator profile on Douyin and copy its full `/user/` URL.
2. Paste it into **Public creator profile URLs**. Short share links are not supported.
3. Set **Maximum creator profiles** to the desired global cap.
4. Run the Actor and inspect the Creator snapshots dataset view.
5. Export JSON, CSV or Excel using Apify's dataset export controls.

The prefilled example supplies one public creator profile. Its metrics change over time.

### Input parameters

| Field | Meaning |
| --- | --- |
| `startUrls` | Required list of 1–100 public HTTPS Douyin `/user/<sec_uid>` URLs; each entry is an object with a `url` property. |
| `maxItems` | Global distinct-profile cap, default 10, range 1–100. Zero is invalid. |

URLs are trimmed, canonicalized to `www.douyin.com`, and stripped of trailing slashes, query strings and fragments. Duplicate canonical URLs count once, in first-seen order. All URLs are validated before applying the cap. Only `url` is used from each request-list entry; editor-generated `method`, `payload`, `headers` and `userData` fields are ignored, not forwarded. Do not supply credentials. There are no filters, discovery modes or post-pagination options.

```json
{
  "startUrls": [
    {"url": "https://www.douyin.com/user/MS4wLjABAAAAk1tZ-L085zZf2yW_H5dnVFZWyk8Rt8v4RAvf9KhTyPoVdMDxTs7Q_rvgTJGWXezS"}
  ],
  "maxItems": 1
}
```

### Extracted data

| Field | Meaning |
| --- | --- |
| `profileUrl` | Canonical source profile URL. |
| `secUid` | Stable public security UID; checked against your requested profile. |
| `uid` | Public numeric user ID stored as text to preserve precision. |
| `handle` | Public Douyin ID, when exposed. |
| `nickname` | Current creator display name. |
| `bio` | Public biography, or null. |
| `followers`, `following` | Public exact counters; following can be null when absent. |
| `totalLikes` | Total likes received by the creator, not individual-post engagement. |
| `postCount` | Public works counter; no posts are downloaded. |
| `avatarUrl` | Public avatar URL, which may expire; no image bytes downloaded. |
| `ipRegion` | Douyin's public region label, not a raw IP or precise location. |
| `scrapedAt` | UTC retrieval timestamp. |

### Output example

The structure below is anonymized from an observed current profile response. Optional unavailable fields are null. Counts are illustrative, not guaranteed current values.

```json
{
  "profileUrl": "https://www.douyin.com/user/MS4wLjABAAAAexample123456",
  "secUid": "MS4wLjABAAAAexample123456",
  "uid": "1234567890123456",
  "handle": "examplecreator",
  "nickname": "Example Creator",
  "bio": "Language learning and everyday life.",
  "followers": 48322,
  "following": 21,
  "totalLikes": 92060,
  "postCount": 212,
  "avatarUrl": "https://p3-pc.douyinpic.com/example.jpeg",
  "ipRegion": "内蒙古",
  "scrapedAt": "2026-10-16T06:06:42.861Z"
}
```

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

Pay per event: a $0.002 start fee per run plus $0.0075306 per saved creator profile on the Bronze plan. Other plans have tier-specific per-profile prices displayed in the Pricing tab.

Bronze example totals including the start fee: 1 result → $0.0095306; 10 results → $0.077306; 100 results → $0.75506 for a single run. No separate charge exists for individual fields. Failed or missing profiles do not generate a profile event; an already charged start fee and earlier saved rows can remain billed on a failed run. Platform spending limits can stop collection before your requested cap.

### Limits and failure behavior

The Actor processes profiles sequentially using anonymous browser sessions and no paid proxy fallback. It makes at most two attempts per profile: an 8-second initial response window, then a fresh anonymous session with up to 40 seconds for recovery. It retires a failed session before retrying; a recovered profile is saved and charged only once. Healthy anonymous cookies are reused for at most ten successful profiles within a run, then discarded together with the browser process before starting the next cohort. Allow tens of seconds per profile; upstream delays can extend this. Increase the run timeout when processing larger supplied lists.

A deleted, private, blocked or incomplete profile fails the run rather than producing a misleading empty success or zero-filled record. Rows saved before the failure remain available as **partial results**, not proof that every requested creator succeeded. Check terminal status before treating an export as complete.

Browser challenges and Douyin changes can interrupt access. Recent-post endpoints are deliberately excluded; a public works counter does not mean individual works can be exported.

### Scheduling snapshots

Schedule this Actor with Apify to capture your supplied shortlist periodically. Join exports by `secUid` and compare `scrapedAt` snapshots in your database or spreadsheet. A counter difference is not automatically campaign-attributed growth.

### Integrations

Use Apify webhooks to notify downstream processing after a successful run. Send dataset exports to Google Sheets through Make, n8n, or Zapier, or load JSON into a warehouse. These integrations require your own configuration; the Actor does not send alerts or maintain historical storage across runs.

### API usage

Replace `APIFY_TOKEN` with your securely stored Apify token. The same input contract applies to Console and API runs.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~douyin-creator-profiles/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data-binary @input.json
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/douyin-creator-profiles').call(input);
if (run.status !== 'SUCCEEDED') throw new Error(`Partial run: ${run.id}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/douyin-creator-profiles').call(run_input=actor_input)
if run['status'] != 'SUCCEEDED':
    raise RuntimeError('Run failed; dataset may be partial')
items = client.dataset(run['defaultDatasetId']).list_items(limit=100).items
```

### Use with MCP

Use this Actor-specific hosted endpoint:

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

For **Claude Desktop**, **Cursor**, and **VS Code** clients supporting HTTP MCP configuration:

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

Authenticate with your Apify account as required by your client. Discover actual names and schemas using read-only `tools/list`; selecting an Actor also exposes run and storage helpers, not exactly one tool.

Example prompts: “Fetch current public counters for these supplied Douyin profile URLs, then show the nickname, followers, totalLikes and retrieval time.” An authorized invocation starts once; retain the returned run ID and follow that same run using `get-actor-run`. A start response is metadata, not dataset rows. `call-actor` waits at most 45 seconds; use bounded polling, for example 2/4/8-second intervals capped at 10 seconds and a 120-second deadline. On timeout, check the known run instead of starting another. At deadline report pending and its ID.

After success, use `get-dataset-items` with explicit fields, offset and limit. A practical consumer budget is pages of 20 rows, at most 100 rows and 64 KiB of serialized results admitted to model context, whichever comes first. Enforce the byte budget host-side before model injection; disclose any oversized omitted page. If your client cannot intercept results, do not claim that byte ceiling. Report continuation offset and partial status, keeping full exports outside model context. Discovery caching and token behavior depend on the client; no numeric token savings are promised.

### Legality, responsible use and privacy

Collect only public profiles you have a lawful basis to process. Respect applicable laws, Douyin terms, privacy rights and reasonable scheduling frequency. Public availability does not grant unrestricted reuse. This Actor is not affiliated with Douyin or ByteDance and cannot bypass account access restrictions.

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. Raw profile API responses, cookies and browser state are not product output. Browser sessions are ephemeral and closed within the run. Apify stores your dataset, input and logs under your account's retention settings; delete them in Console when no longer needed. The Actor does not send scraped data to an AI provider and does not use AI at runtime. Infrastructure and diagnostics are company-paid; there is no undisclosed third-party subscription required.

For help, open an issue on this Actor's Apify Store Issues tab with your run link and a safe description of the affected profile. Do not share passwords or cookies.

### FAQ and troubleshooting

**Does this work with TikTok URLs?** No. Douyin and TikTok are different platforms.

**Can I enter a handle or share link?** No. Open the full public Douyin creator page and supply its `/user/<sec_uid>` URL.

**Why did my run fail with some rows present?** A later profile was unavailable, incomplete or blocked after bounded attempts. Earlier rows are partial. Verify the source profile before retrying; do not repeatedly rerun an unchanged blocked request.

**Can I retrieve recent videos or historical counters?** No. Only current profile snapshots and the public works count are supported. Schedule future captures and retain your own history.

**Why is a value null?** Douyin did not expose that optional value in the successful profile response. Null is not zero. A missing required identity or follower counter is treated as an incomplete response and fails the run.

### Related Actors

- [Douyin Hot Search Trends Scraper](https://apify.com/automation-lab/douyin-hot-search-trends) for topic rankings, not creator snapshots.
- [Douyin Analytics Scraper](https://apify.com/automation-lab/douyin-analytics-scraper) for public hot-search topics, not supplied creator profiles.

Use related outputs as separate data sources; this Actor does not join them automatically.

# Changelog

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

# Actor input Schema

## `startUrls` (type: `array`):

Supply 1–100 HTTPS douyin.com/user/\<sec_uid> URLs. Short share links, handles, numeric IDs, search and video URLs are rejected. Query strings and trailing slashes are removed; duplicate canonical URLs count once, in first-seen order. All supplied URLs are validated before the run starts. Only each entry's url is used; editor-generated method, payload, headers and userData options are ignored and are not forwarded to Douyin.

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

Global maximum distinct supplied profiles to process, after URL normalization and deduplication. Default 10, range 1–100; zero is invalid. No discovery or post pagination occurs. A platform charge or runtime limit can stop a run sooner. An unavailable profile fails the run; preceding rows remain partial results.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.douyin.com/user/MS4wLjABAAAAk1tZ-L085zZf2yW_H5dnVFZWyk8Rt8v4RAvf9KhTyPoVdMDxTs7Q_rvgTJGWXezS"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Current profile identity and public metrics; failed runs may contain partial results.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.douyin.com/user/MS4wLjABAAAAk1tZ-L085zZf2yW_H5dnVFZWyk8Rt8v4RAvf9KhTyPoVdMDxTs7Q_rvgTJGWXezS"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/douyin-creator-profiles").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 = { "startUrls": [{ "url": "https://www.douyin.com/user/MS4wLjABAAAAk1tZ-L085zZf2yW_H5dnVFZWyk8Rt8v4RAvf9KhTyPoVdMDxTs7Q_rvgTJGWXezS" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/douyin-creator-profiles").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 '{
  "startUrls": [
    {
      "url": "https://www.douyin.com/user/MS4wLjABAAAAk1tZ-L085zZf2yW_H5dnVFZWyk8Rt8v4RAvf9KhTyPoVdMDxTs7Q_rvgTJGWXezS"
    }
  ]
}' |
apify call automation-lab/douyin-creator-profiles --silent --output-dataset

```

## MCP server setup

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

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/Y2zabiC6yYNmLMcQd/builds/erj5pcFto0KK8mdF7/openapi.json