# TikTok Followers & Following Scraper (`crawlerbros/tiktok-followers-scraper`) Actor

Scrape the followers and following lists for TikTok profiles. Input usernames or profile URLs. Supports pagination up to thousands of users. No cookies required.

- **URL**: https://apify.com/crawlerbros/tiktok-followers-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## TikTok Followers Scraper

Scrape the followers or following list for any TikTok account. Returns one row per user with full profile info and engagement stats. The following list (who the account follows) works without any cookie. The followers list (who follows the account) requires a `sessionCookie` because TikTok's followers API enforces authentication.

### What this actor does

- Accepts TikTok usernames (with or without @) and/or full profile URLs
- Scrapes the following list — accounts the target user follows — without any authentication
- Scrapes the followers list — accounts that follow the target user — when a `sessionCookie` is provided
- Can scrape both lists in a single run
- Returns username, display name, bio, avatar, verification status, and organization flag per user
- Optionally includes follower/following/heart/video counts from statsV2 for each user
- Paginates up to 5,000 users per profile
- Empty fields are omitted

### Output per user

- `sourceUsername` — the profile that was queried
- `sourceUserId` — TikTok user ID of the queried profile
- `listType` — `"followers"` or `"following"`
- `userId` — TikTok user ID (18–19 digit string)
- `secUid` — TikTok secUid for API calls
- `username` — TikTok @handle
- `displayName` — display name / nickname
- `verified` — whether this user has a verified badge
- `isOrganization` — whether this is a business/organization account
- `privateAccount` — whether this account is private
- `bio` — profile bio/signature text
- `avatarUrl` — avatar image URL
- `followerCount` — number of followers (from statsV2)
- `followingCount` — number of accounts this user follows (from statsV2)
- `heartCount` — total likes received across all videos (from statsV2)
- `videoCount` — number of public videos posted (from statsV2)
- `scrapedAt` — ISO 8601 timestamp when the record was collected

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `usernames` | array | — | TikTok usernames to scrape (with or without @) |
| `profileUrls` | array | — | Full TikTok profile URLs as alternative or additional input |
| `listType` | string | `"following"` | `"following"` (no cookie needed), `"followers"` (requires sessionCookie), or `"both"` |
| `maxUsersPerProfile` | integer | `100` | Maximum users to fetch per profile (up to 5,000) |
| `includeStats` | boolean | `true` | Include follower/following/heart/video counts per user |
| `sessionCookie` | string | — | TikTok `sessionid` cookie value — required for followers mode |

#### Example: Following list — no cookie needed

```json
{
  "usernames": ["natgeo"],
  "listType": "following",
  "maxUsersPerProfile": 30,
  "includeStats": true
}
````

#### Example: Followers list — requires sessionCookie

```json
{
  "usernames": ["natgeo"],
  "listType": "followers",
  "maxUsersPerProfile": 500,
  "includeStats": true,
  "sessionCookie": "your_sessionid_value_here"
}
```

#### Example: Both lists for multiple profiles

```json
{
  "usernames": ["natgeo", "bbcnews"],
  "listType": "both",
  "maxUsersPerProfile": 200,
  "includeStats": true,
  "sessionCookie": "your_sessionid_value_here"
}
```

#### Example: Following list — lightweight, no stats

```json
{
  "usernames": ["khaby.lame"],
  "listType": "following",
  "maxUsersPerProfile": 1000,
  "includeStats": false
}
```

### Use cases

- **Influencer scouting** — discover which accounts top creators follow to find emerging talent before they go viral
- **Audience research** — export a brand account's follower list for CRM enrichment or lookalike audience building
- **Competitive analysis** — identify follower overlap between competing accounts or creators in the same niche
- **Partnership vetting** — check whether a target influencer follows brand accounts or competitor handles
- **Community mapping** — map the follow graph around a specific creator or brand to understand their ecosystem
- **Social analytics export** — build structured datasets of TikTok user profiles for social media intelligence platforms

### FAQ

**Do I need a TikTok account or cookies?**
It depends on the mode. `listType: "following"` is fully public — no cookie needed. `listType: "followers"` requires a `sessionCookie` because TikTok's followers API (`scene=151`) ignores the target account parameters without authentication and returns a generic regional list.

**How do I get my sessionCookie?**
Install the Cookie-Editor browser extension, log into TikTok at tiktok.com, click the icon, find the cookie named `sessionid`, and copy its value. Paste that value into the `sessionCookie` field.

**Why does `heartCount` come from statsV2?**
TikTok's legacy `stats.heart` field uses a 32-bit integer that overflows to negative values for large creators with billions of likes. `statsV2.heartCount` is a string and never overflows.

**Can I scrape the following list of a private account?**
The following list of a private account is not publicly accessible via TikTok's API.

**Can I get more than 5,000 users?**
5,000 is the practical limit per profile enforced by TikTok's pagination. Set `maxUsersPerProfile` to 5,000 for the maximum.

**How long does it take to scrape 1,000 users?**
Approximately 5 minutes per 1,000 users due to API pagination delays.

**Can I scrape multiple profiles at once?**
Yes. Add multiple entries to `usernames` or `profileUrls`. Profiles are scraped sequentially.

**Are TikTok usernames case-sensitive?**
No. TikTok usernames are case-insensitive and the actor normalizes them automatically.

**What happens if `listType: "followers"` is used without a sessionCookie?**
Without a cookie, TikTok's followers API ignores `targetUserId` and returns a generic regional user list unrelated to the queried account. Always provide a `sessionCookie` for followers mode.

### Related TikTok Scrapers

Build a complete TikTok data pipeline with our full suite:

| Scraper | URL |
|---|---|
| TikTok Post Scraper | https://apify.com/crawlerbros/tiktok-post-scraper |
| TikTok Profile Scraper | https://apify.com/crawlerbros/tiktok-profile-scraper |
| TikTok Comments Scraper | https://apify.com/crawlerbros/tiktok-comments-scraper |
| TikTok Search Scraper | https://apify.com/crawlerbros/tiktok-search-scraper |
| TikTok Hashtag Scraper | https://apify.com/crawlerbros/tiktok-hashtag-scraper |
| TikTok Music Scraper | https://apify.com/crawlerbros/tiktok-music-scraper |
| TikTok Transcript Scraper | https://apify.com/crawlerbros/tiktok-transcript-scraper |
| TikTok Mention Scraper | https://apify.com/crawlerbros/tiktok-mention-scraper |
| TikTok Profile Mention Scraper | https://apify.com/crawlerbros/tiktok-profile-mention-scraper |
| TikTok Playlist Scraper | https://apify.com/crawlerbros/tiktok-playlist-scraper |
| TikTok Explore Scraper | https://apify.com/crawlerbros/tiktok-explore-scraper |
| TikTok For You Scraper | https://apify.com/crawlerbros/tiktok-for-you-scraper |
| TikTok Downloader | https://apify.com/crawlerbros/tiktok-downloader-api |
| TikTok Ads Library Scraper | https://apify.com/crawlerbros/tiktok-ads-library-scraper-pro |
| TikTok Top Ads Scraper | https://apify.com/crawlerbros/tiktok-top-ads-scraper |
| TikTok Hashtag Trends Scraper | https://apify.com/crawlerbros/tiktok-hashtag-trends-scraper |
| TikTok LIVE Scraper | https://apify.com/crawlerbros/tiktok-live-scraper |

# Actor input Schema

## `usernames` (type: `array`):

TikTok usernames (with or without @) to fetch followers/following for.

## `profileUrls` (type: `array`):

TikTok profile URLs as alternative or additional input. E.g. https://www.tiktok.com/@natgeo

## `listType` (type: `string`):

Choose whether to scrape followers, following, or both lists for each profile. NOTE: 'followers' requires a sessionCookie — without it TikTok's API returns a generic list, not the account's real followers. 'following' works without a cookie.

## `maxUsersPerProfile` (type: `integer`):

Maximum number of follower or following users to fetch per profile.

## `includeStats` (type: `boolean`):

Include follower/following/heart/video counts from statsV2 for each user in the output.

## `sessionCookie` (type: `string`):

Value of the TikTok `sessionid` cookie. **Required to scrape followers** — without it, TikTok's API ignores the target account and returns a generic regional list. Not needed for 'following' mode. To obtain: install Cookie-Editor extension → log into TikTok → click Cookie-Editor → find 'sessionid' → copy its Value.

## Actor input object example

```json
{
  "usernames": [
    "natgeo"
  ],
  "listType": "following",
  "maxUsersPerProfile": 30,
  "includeStats": true
}
```

# Actor output Schema

## `data` (type: `string`):

Dataset containing follower/following user records. Fields: userId, secUid, username, displayName, verified, isOrganization, privateAccount, bio, avatarUrl, followerCount, followingCount, heartCount, videoCount, listType, sourceUsername, sourceUserId, scrapedAt.

# 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 = {
    "usernames": [
        "natgeo"
    ],
    "listType": "following",
    "maxUsersPerProfile": 30,
    "includeStats": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/tiktok-followers-scraper").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 = {
    "usernames": ["natgeo"],
    "listType": "following",
    "maxUsersPerProfile": 30,
    "includeStats": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/tiktok-followers-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "usernames": [
    "natgeo"
  ],
  "listType": "following",
  "maxUsersPerProfile": 30,
  "includeStats": true
}' |
apify call crawlerbros/tiktok-followers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/tiktok-followers-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Followers & Following Scraper",
        "description": "Scrape the followers and following lists for TikTok profiles. Input usernames or profile URLs. Supports pagination up to thousands of users. No cookies required.",
        "version": "1.0",
        "x-build-id": "GzI0tcI9tXBjmwz0f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~tiktok-followers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-tiktok-followers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~tiktok-followers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-tiktok-followers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~tiktok-followers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-tiktok-followers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "TikTok usernames (with or without @) to fetch followers/following for.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "profileUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "TikTok profile URLs as alternative or additional input. E.g. https://www.tiktok.com/@natgeo",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listType": {
                        "title": "List Type",
                        "enum": [
                            "followers",
                            "following",
                            "both"
                        ],
                        "type": "string",
                        "description": "Choose whether to scrape followers, following, or both lists for each profile. NOTE: 'followers' requires a sessionCookie — without it TikTok's API returns a generic list, not the account's real followers. 'following' works without a cookie.",
                        "default": "following"
                    },
                    "maxUsersPerProfile": {
                        "title": "Max Users Per Profile",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of follower or following users to fetch per profile.",
                        "default": 100
                    },
                    "includeStats": {
                        "title": "Include User Stats",
                        "type": "boolean",
                        "description": "Include follower/following/heart/video counts from statsV2 for each user in the output.",
                        "default": true
                    },
                    "sessionCookie": {
                        "title": "TikTok Session Cookie (required for followers list)",
                        "type": "string",
                        "description": "Value of the TikTok `sessionid` cookie. **Required to scrape followers** — without it, TikTok's API ignores the target account and returns a generic regional list. Not needed for 'following' mode. To obtain: install Cookie-Editor extension → log into TikTok → click Cookie-Editor → find 'sessionid' → copy its Value."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
