# TikTok Creator Growth Tracker (`coregent/tiktok-creator-growth-tracker`) Actor

Track TikTok creators over time. Monitor follower gains, total likes, following, video-count changes, posting activity, engagement trends, milestones, and growth acceleration.

- **URL**: https://apify.com/coregent/tiktok-creator-growth-tracker.md
- **Developed by:** [Delowar Munna](https://apify.com/coregent) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 creator snapshots

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

## TikTok Creator Growth Tracker

![TikTok Creator Growth Tracker](https://raw.githubusercontent.com/coregentdevspace/tiktok-creator-growth-tracker-assets/main/thumbnail-tiktok-creator-growth-tracker.png)

Track TikTok creators over time. Monitor follower gains, total likes, following, video-count changes, posting activity, engagement trends, milestones, and growth acceleration — from scheduled runs that remember every previous observation.

### What does this Actor do?

**TikTok Creator Growth Tracker** stores a snapshot of each creator's public profile every time it runs and compares it with that creator's history. One output row = one creator × one observation, with:

- **Current counters** — followers, following, friends, total likes, video count, verified/private status
- **Deltas & growth %** since the previous snapshot — followers, following, friends, likes, videos
- **Velocity** — followers per day / week / 30 days, likes per day, videos per week, normalized for uneven schedules
- **Period comparisons** — 24 hours, 7 days, 30 days, 90 days, each matched to the nearest stored snapshot
- **Trend & acceleration** — `SURGING` / `GROWING` / `STABLE` / `DECLINING` / `SHARP_DECLINE`, and `ACCELERATING` / `STEADY` / `DECELERATING`
- **Milestones** — `CROSSED_10K`, `CROSSED_100K`, `CROSSED_1M`, … the run a creator crosses them
- **Signals & alerts** — follower surges/drops, like surges, posting and engagement shifts, username and profile changes, with your own alert thresholds
- **Optional recent-video performance** — average **and** median views, likes, comments, shares, saves, engagement rate, posting frequency

### How is this different from a TikTok Profile Scraper?

A profile scraper answers *"how many followers does this creator have now?"* This Actor answers *"how is this creator changing over time?"* It keeps persistent per-project history, so each run returns growth analytics — not just today's numbers.

### Who is it for?

- **Influencer marketing teams & agencies** — weekly growth reports for client creators
- **Talent managers** — monitor a roster's momentum and milestones
- **Brands** — vet creators before a partnership; evaluate growth around a campaign
- **Competitor & market researchers** — benchmark creators in a niche over time
- **Data teams** — feed clean, flat growth rows into Sheets, BI tools, or AI workflows

### Quick start

1. Add creators — usernames, `@handles`, profile URLs, user IDs, or secUids.
2. Pick a `trackerKey` (e.g. `creator-watchlist`) — keep it the same on every run.
3. Run once to create **baselines**, then **schedule** the Actor (daily is recommended).

#### Minimal input

```json
{
  "creators": ["@tiktok", "@khaby.lame"]
}
```

The first run creates baselines. Growth appears from the second run.

#### Daily creator watchlist

```json
{
  "creators": ["@tiktok", "@khaby.lame", "https://www.tiktok.com/@charlidamelio"],
  "trackerKey": "creator-watchlist",
  "mode": "TRACK",
  "comparisonPeriods": ["PREVIOUS", "7_DAYS", "30_DAYS"],
  "includeRecentVideoMetrics": true,
  "videosForPerformance": 10
}
```

#### Creator & brand watchlist with alerts (20 creators)

The input behind the sample output below — creators and brands mixed, entered as `@handles`, bare usernames and profile URLs:

```json
{
  "creators": [
    "@khaby.lame", "@charlidamelio", "@mrbeast", "@bellapoarch", "@zachking",
    "@addisonre", "@willsmith", "@therock", "@kimberly.loaiza", "@domelipa",
    "@selenagomez", "@jimmyfallon", "@gordonramsayofficial", "@scout2015", "@brentrivera",
    "duolingo", "netflix", "nba",
    "https://www.tiktok.com/@espn", "https://www.tiktok.com/@tiktok"
  ],
  "mode": "TRACK",
  "trackerKey": "readme-demo",
  "comparisonPeriods": ["PREVIOUS", "24_HOURS", "7_DAYS", "30_DAYS"],
  "includeRecentVideoMetrics": true,
  "videosForPerformance": 10,
  "growthAlertThresholdPct": 0.5,
  "growthAlertThresholdAbsolute": 5000,
  "dropAlertThresholdPct": -0.5
}
```

#### Lightweight large-scale tracking (profile counters only)

```json
{
  "creators": ["@creator1", "@creator2"],
  "trackerKey": "large-watchlist",
  "includeRecentVideoMetrics": false,
  "includeProfileMetadata": false,
  "saveHistory": true
}
```

#### Breakout alerts

```json
{
  "creators": ["@creator1", "@creator2"],
  "trackerKey": "breakout-creators",
  "growthAlertThresholdPct": 5,
  "growthAlertThresholdAbsolute": 10000,
  "comparisonPeriods": ["24_HOURS", "7_DAYS"]
}
```

### Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `creators` | string\[] | `["@tiktok"]` | Username, @handle, profile URL, user ID, or secUid. Up to 1,000 per run (required) |
| `mode` | string | `TRACK` | `TRACK` (previous + selected periods), `COMPARE` (all periods), `SNAPSHOT` (record counters only) |
| `trackerKey` | string | `default` | History namespace — independent projects use different keys |
| `comparisonPeriods` | string\[] | `PREVIOUS`, `7_DAYS`, `30_DAYS` | Also `24_HOURS`, `90_DAYS` |
| `includeRecentVideoMetrics` | boolean | `true` | Recent-video performance sample (billed separately, only when videos are returned) |
| `videosForPerformance` | integer | `10` | Sample size; TikTok caps one public page at about 10 |
| `includePostingMetrics` | boolean | `true` | Videos in last 7/30 days, posts per week, days since last video |
| `includeProfileMetadata` | boolean | `true` | Bio, bio link, avatar, business flags, language, created date + change tracking |
| `saveHistory` | boolean | `true` | Store this observation for future comparisons |
| `maxHistoryDays` | integer | `365` | Snapshot retention for period comparisons |
| `minimumSnapshotIntervalMinutes` | integer | `30` | Re-runs inside this window with no counter change don't write duplicate history |
| `growthAlertThresholdPct` | number | — | Alert when follower growth in any compared period ≥ this % |
| `growthAlertThresholdAbsolute` | integer | — | Alert when followers gained in any compared period ≥ this number |
| `dropAlertThresholdPct` | number | — | Alert when follower growth in any compared period ≤ this % (e.g. `-3`) |

### Output

Each row has **flat core fields** (spreadsheet- and CSV-friendly) plus **nested detail** objects. Dataset views: **Growth Overview**, **24h / 7d / 30d / 90d**, **Signals & Alerts**, **Content Performance**, **Full Data**. A run summary (creators succeeded, baselines, trend counts, signals, TikHub call accounting) is saved to the run's key-value store as `SUMMARY`.

The samples below are real rows from the 20-creator watchlist input above, on its **second run, 47 minutes after the baselines**. Deltas are already filled; `followersPerDay` (needs ≥ 1 hour between snapshots), `growthTrend` (needs ≥ 12 hours, or a 7-day comparison) and the 24h / 7d / 30d periods stay `null` until enough time has passed — schedule the Actor daily and they fill in.

#### Growth Overview

![Growth Overview table view](https://raw.githubusercontent.com/coregentdevspace/tiktok-creator-growth-tracker-assets/main/tiktok-creator-growth-tracker-output-growth-overview-table-view.png)

```json
{
  "rowType": "tiktok_creator_growth_snapshot",
  "trackerKey": "readme-demo",
  "input": "@mrbeast",
  "username": "mrbeast",
  "nickname": "MrBeast",
  "userId": "6614519312189947909",
  "profileUrl": "https://www.tiktok.com/@mrbeast",
  "followers": 144903368,
  "following": 346,
  "totalLikes": 1548596672,
  "videoCount": 485,
  "verified": true,
  "countPrecision": "EXACT",
  "observedAt": "2026-10-26T05:56:04.274Z",
  "isBaseline": false,
  "previousObservedAt": "2026-10-26T05:08:35.995Z",
  "elapsedHours": 0.79,
  "followersDelta": 1677,
  "followersGrowthPct": 0.001,
  "followersPerDay": null,
  "totalLikesDelta": 31334,
  "videoCountDelta": 0,
  "followers24hDelta": null,
  "followers7dDelta": null,
  "growthTrend": "INSUFFICIENT_HISTORY",
  "growthAcceleration": "INSUFFICIENT_HISTORY",
  "signals": [],
  "milestonesCrossed": [],
  "alertTriggered": false,
  "alertReasons": [],
  "snapshotCount": 2,
  "firstTrackedAt": "2026-10-26T05:08:35.995Z",
  "status": "SUCCESS"
}
```

#### Content Performance

```json
{
  "username": "netflix",
  "followers": 54089116,
  "avgViews": 204913.1,
  "medianViews": 77355.5,
  "avgLikes": 11571.3,
  "avgComments": 77.2,
  "avgShares": 319.6,
  "engagementRate": 0.022,
  "postingFrequencyPerWeek": 52.14,
  "videosInLast30Days": 10,
  "daysSinceLastVideo": 0.4,
  "recentVideosStatus": "SUCCESS"
}
```

#### Nested detail (Full Data)

`growthPeriods.previous` for `@mrbeast`, plus `contentPerformance` and one of `recentVideos` for `@netflix`:

```json
{
  "growthPeriods": {
    "previous": {
      "baselineAt": "2026-10-26T05:08:35.995Z",
      "elapsedHours": 0.79,
      "followersDelta": 1677,
      "followingDelta": 0,
      "friendsDelta": 0,
      "totalLikesDelta": 31334,
      "videoCountDelta": 0,
      "followersGrowthPct": 0.001,
      "totalLikesGrowthPct": 0.002,
      "followersPerDay": null,
      "followersPerWeek": null,
      "likesPerDay": null,
      "medianViewsDelta": 8936,
      "engagementRateDelta": 0.001,
      "followersDeltaBelowPrecision": false
    }
  },
  "contentPerformance": {
    "videosAnalyzed": 10,
    "avgViews": 204913.1,
    "medianViews": 77355.5,
    "avgLikes": 11571.3,
    "medianLikes": 4458,
    "avgSaves": 806,
    "medianSaves": 359,
    "engagementRate": 0.022,
    "viewToFollowerRatio": 0.0014,
    "videosInLast7Days": 10,
    "videosInLast30Days": 10,
    "postingFrequencyPerWeek": 52.14,
    "daysSinceLastVideo": 0.4,
    "postingSampleSaturated": true
  },
  "recentVideos": [
    {
      "videoId": "7700713094187683085",
      "videoUrl": "https://www.tiktok.com/@netflix/video/7700713094187683085",
      "createdAt": "2026-10-25T21:00:00.000Z",
      "views": 81905,
      "likes": 10551,
      "comments": 100,
      "shares": 840,
      "saves": 908,
      "duration": 63,
      "isPinned": false
    }
  ]
}
```

Netflix's `postingSampleSaturated: true` means all 10 sampled videos fall within the last 30 days — it posts so often that the true cadence may be higher than the sample shows.

#### Statuses

`SUCCESS`, `BASELINE_CREATED`, `PROFILE_PRIVATE`, `VIDEOS_UNAVAILABLE` (profile tracked, video sample failed), `PROFILE_NOT_FOUND`, `PROFILE_UNAVAILABLE`, `PARTIAL_PROFILE`, `USERNAME_CHANGED_UNKNOWN`, `RATE_LIMITED`, `PROVIDER_ERROR`, `STATE_READ_ERROR`, `STATE_WRITE_ERROR`, `INVALID_INPUT`, `DUPLICATE_INPUT`, `SKIPPED_TOO_MANY_FAILURES` (the run stopped looking up creators after most inputs returned no profile — check for misspelled or deleted accounts). One failed creator never fails the run.

### FAQ

**What happens on the first run?**
Each creator gets a baseline: current counters are stored, `isBaseline` is `true`, all deltas are `null`, and trend/acceleration are `INSUFFICIENT_HISTORY`. The Actor never reports "0 growth" when it has nothing to compare against, and it cannot show growth from before the first observation.

**Which profile counters are tracked?**
Followers, following, friends, total likes, and video count — plus verified, private, and (with metadata on) bio, bio link, business category and similar fields for change tracking.

**Are counts exact or rounded?**
Every row has `countPrecision`: `EXACT` when TikTok's unrounded counters are available (the usual case), `ROUNDED` when only display-rounded values are (e.g. 1.2M), `UNKNOWN` otherwise. A delta smaller than the rounding step is flagged (`followersDeltaBelowPrecision`) and does not count as growth.

**How is follower growth calculated?**
`followersDelta = current − previous`; `followersGrowthPct = delta ÷ previous × 100` (`null` if the previous value is missing or zero).

**How does uneven scheduling affect velocity?**
It doesn't distort it: velocity divides by the real elapsed time (`followersPerDay = delta ÷ elapsed days`), so a run 36 hours after the last one is comparable to a 24-hour one. Rates are withheld for gaps under an hour.

**Can I compare 7, 30 and 90-day growth?**
Yes. Each period uses the stored snapshot closest to that age within a tolerance — 24h ±6h, 7d ±24h, 30d ±3d, 90d ±7d. A period returns `null` until that much history exists. Use `COMPARE` mode for all periods at once.

**What does SURGING mean?**
Follower growth normalized to a 7-day rate: `SURGING` ≥ 5%/week, `GROWING` ≥ 0.5%, `STABLE` between −0.5% and 0.5%, `DECLINING` down to −3%, `SHARP_DECLINE` below that. It uses the 7-day comparison when available, otherwise the previous snapshot (if at least 12 hours old). These classifications are Coregent-derived, not TikTok metrics.

**What is growth acceleration?**
Recent follower velocity compared with the previous equivalent period — the last 7 days vs the 7 days before when history allows, otherwise the last two intervals between snapshots. A change of more than 20% is `ACCELERATING` or `DECELERATING`; otherwise `STEADY`.

**What happens if a username changes?**
History follows the creator, not the handle. State is keyed by TikTok's stable user ID, and the creator is looked up by their stable secUid, so a renamed creator still resolves. The row shows `usernameChanged: true` with `previousUsername` and `currentUsername`, plus a `USERNAME_CHANGED` signal.

**Can I track multiple independent projects?**
Yes — use a different `trackerKey` for each. The same creator under two keys has two independent histories.

**Can I track private creators?**
Public counters are tracked and the row is marked `PROFILE_PRIVATE`. Recent-video metrics are unavailable for private accounts. The Actor never bypasses privacy.

**Does it include recent-video metrics?**
Yes, optionally (`includeRecentVideoMetrics`, on by default). It analyzes the creator's latest public videos: one page, currently about 10 videos.

**How are average and median views calculated?**
Over the video sample. Both are returned because TikTok is highly skewed — one viral video can make the average misleading. `engagementRate` = (avg likes + avg comments + avg shares) ÷ followers × 100; it's a Coregent-derived ratio, not an official TikTok metric. If every sampled video falls within the last 30 days, `postingSampleSaturated` is `true` — the creator may have posted more than the sample shows.

**Does it require TikTok login or cookies?**
No. Only publicly available data is used, and no login, cookies or session IDs are needed.

**Does it use TikHub?**
Yes. Profiles and videos are fetched through the TikHub API — browserless, with no proxy setup on your side.

**How often should I schedule it?**
Daily for most watchlists; every 12 hours for fast-growing creators. Hourly is rarely useful. Create an Apify **Task** with your input and attach a **Schedule**.

**Can it trigger webhooks?**
Yes. Every row has `alertTriggered` and `alertReasons` (e.g. `FOLLOWER_SURGE`, `FOLLOWER_DROP`, `CROSSED_100K`, `CROSSED_1M`, `ACCELERATING_GROWTH`, `BECAME_VERIFIED`, `BIO_LINK_CHANGED`, `USERNAME_CHANGED`). Add an Apify webhook on run success, or connect the dataset to Slack, email, Google Sheets, Make, Zapier or n8n and filter on `alertTriggered`.

**Can I use it via API or MCP?**
Yes — run it via the Apify API, the Apify client libraries, or as a tool through the Apify MCP server. Example:

```bash
curl -X POST "https://api.apify.com/v2/acts/coregent~tiktok-creator-growth-tracker/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"creators":["@tiktok"],"trackerKey":"api-watchlist"}'
```

**How does pricing work?**
Pay-per-event, with no start fee:

- **Creator snapshot** — each creator successfully observed (first-run baselines included, because they cost the same to fetch).
- **Video analytics** — each creator whose recent-video sample was actually delivered (only when `includeRecentVideoMetrics` is on).

Not-found, invalid, duplicate, and failed creators are free, and the run summary is free. See the **Pricing** tab for current rates. This README deliberately doesn't quote figures, because they can change. The Actor respects your **maximum cost per run**: when it is reached, remaining creators are skipped.

### Where is history stored?

In your own Apify account, in storages the Actor creates on its first run:

- key-value store **`tiktok-creator-growth-state`** — latest state and compact history per `trackerKey` + creator
- dataset **`tiktok-creator-growth-history`** — append-only log, one row per saved observation, for exports

Deleting those storages resets all tracking history.

### Limitations & interpretation

- Unofficial product; not affiliated with TikTok or ByteDance. Uses only publicly accessible data.
- Growth metrics are discrete observations taken when the Actor runs. Tracking begins at the first baseline.
- Public counters can change between observations; some TikTok surfaces expose rounded rather than exact counts.
- Private profiles have limited data; recent-video analytics depend on public video availability.
- Trend, acceleration, signals and engagement rate are Coregent-derived.
- The Actor does **not** provide official TikTok analytics, follower demographics, organic vs paid growth, exact follower-acquisition times, reach, impressions, watch time, audience retention, or growth from before the first observation.

### Related Actors

Pairs with **TikTok Profile Scraper** (one-off profile data), **TikTok Influencer Finder** (find creators worth tracking), and **TikTok Video Scraper** (raw content metrics).

# Actor input Schema

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

TikTok creators to track. Accepts a username, @handle, profile URL (https://www.tiktok.com/@creator), numeric user ID or secUid. Up to 1,000 per run. The first run for each creator creates a baseline; growth appears from the second run on.

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

TRACK (recommended): compare with the previous snapshot and the selected periods. COMPARE: compare against every historical period (24h / 7d / 30d / 90d) where enough history exists. SNAPSHOT: record current counters only (creates/extends history, no growth analytics).

## `trackerKey` (type: `string`):

Name of the history namespace, e.g. agency-client-a or competitor-creators. The same creator tracked under two tracker keys has two independent histories. Use the same key on every scheduled run so growth is compared against the right history.

## `comparisonPeriods` (type: `array`):

Periods to compare in TRACK mode. Each period uses the nearest stored snapshot within a tolerance (24h ±6h, 7d ±24h, 30d ±3d, 90d ±7d) and returns null until that much history exists.

## `includeRecentVideoMetrics` (type: `boolean`):

Fetch a sample of the creator's latest videos and compute average/median views, likes, comments, shares, saves, engagement rate and posting frequency. Billed as a separate video-analytics event, only when videos are actually returned.

## `videosForPerformance` (type: `integer`):

Size of the recent-video sample (suggested 3, 5, 10 or 20). TikTok caps one page of public videos — currently about 10 — so larger values may return fewer videos.

## `includePostingMetrics` (type: `boolean`):

Add videos in the last 7/30 days, posting frequency per week and days since the last video, calculated from real post timestamps in the sample.

## `includeProfileMetadata` (type: `boolean`):

Add bio, bio link, avatar, business/organization flags, language and account creation date, and track changes to them between runs (changedFields). Turn off for leaner rows.

## `saveHistory` (type: `boolean`):

Store this observation so future runs can compare against it. Turn off to compare against existing history without recording a new snapshot.

## `maxHistoryDays` (type: `integer`):

How many days of snapshots to keep for period comparisons (suggested 30, 90, 180, 365, 730). 90-day comparisons need at least ~83 days retained.

## `minimumSnapshotIntervalMinutes` (type: `integer`):

If a creator is re-run within this many minutes and no counter changed, the current data is returned but no duplicate history entry is written.

## `growthAlertThresholdPct` (type: `number`):

Trigger a FOLLOWER_SURGE alert when follower growth in any compared period reaches this percentage, e.g. 5. Leave empty to use the built-in surge signal.

## `growthAlertThresholdAbsolute` (type: `integer`):

Trigger a FOLLOWER_SURGE alert when followers gained in any compared period reach this number, e.g. 10000.

## `dropAlertThresholdPct` (type: `number`):

Trigger a FOLLOWER_DROP alert when follower growth in any compared period falls to or below this percentage, e.g. -3.

## Actor input object example

```json
{
  "creators": [
    "@tiktok"
  ],
  "mode": "TRACK",
  "trackerKey": "default",
  "comparisonPeriods": [
    "PREVIOUS",
    "7_DAYS",
    "30_DAYS"
  ],
  "includeRecentVideoMetrics": true,
  "videosForPerformance": 10,
  "includePostingMetrics": true,
  "includeProfileMetadata": true,
  "saveHistory": true,
  "maxHistoryDays": 365,
  "minimumSnapshotIntervalMinutes": 30
}
```

# Actor output Schema

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

No description

## `periods` (type: `string`):

No description

## `signals` (type: `string`):

No description

## `content` (type: `string`):

No description

## `full` (type: `string`):

No description

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

No description

# 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": [
        "@tiktok"
    ],
    "trackerKey": "default",
    "comparisonPeriods": [
        "PREVIOUS",
        "7_DAYS",
        "30_DAYS"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("coregent/tiktok-creator-growth-tracker").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": ["@tiktok"],
    "trackerKey": "default",
    "comparisonPeriods": [
        "PREVIOUS",
        "7_DAYS",
        "30_DAYS",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("coregent/tiktok-creator-growth-tracker").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": [
    "@tiktok"
  ],
  "trackerKey": "default",
  "comparisonPeriods": [
    "PREVIOUS",
    "7_DAYS",
    "30_DAYS"
  ]
}' |
apify call coregent/tiktok-creator-growth-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,coregent/tiktok-creator-growth-tracker"
        }
    }
}
```

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/sKbgr9r6IoQ2DOcVX/builds/4rZv1Pjvf2XoZ0Vag/openapi.json