# Tiktok Followers Scraper (`api-ninja/tiktok-followers-scraper`) Actor

🔥 Scrape TikTok followers or following at scale from profile URLs, @handles, or user IDs. Fast, paginated, structured, and ready for API, scheduling, and automations on Apify.

- **URL**: https://apify.com/api-ninja/tiktok-followers-scraper.md
- **Developed by:** [API ninja](https://apify.com/api-ninja) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 6 total users, 5 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 1,000 results

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/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

### What does TikTok Followers / Following Scraper do?

**TikTok Followers / Following Scraper** lets you extract **TikTok followers** or **TikTok following lists** from public TikTok profiles such as [tiktok.com](https://www.tiktok.com/). It accepts a simple list of **profile URLs, @handles, usernames, or numeric user IDs**, then collects paginated profile data into a clean dataset you can use immediately.

This Actor is intentionally focused. It does **not** scrape videos, playlists, comments, favorites, or search results. It is built for one job only: getting follower or following profile lists quickly, with structured output and scalable runs on Apify.

Because it runs on the **Apify platform**, you also get key production advantages out of the box:

- 🚀 Run it from the UI or API
- ⏰ Schedule recurring scrapes
- 🔌 Connect it to Make, Zapier, webhooks, or custom pipelines
- 📊 Monitor runs and logs
- 💾 Download results as JSON, CSV, Excel, or HTML

### Why use TikTok Followers / Following Scraper?

If you need TikTok network data without extra noise, this Actor keeps the workflow simple.

Common use cases:

- 👥 Build lists of followers for creator research
- ➡️ Analyze who an account follows
- 📈 Compare audience overlap across multiple creators
- 🎯 Find prospects, influencers, or niche communities
- 🧠 Enrich lead lists or social intelligence datasets
- 🔄 Run recurring monitoring for account growth and relationship changes

This is useful for agencies, growth teams, analysts, lead generation workflows, and anyone who needs **TikTok profile relationship data** without having to scrape unrelated profile content.

### How to scrape TikTok followers or following

Using this Actor is straightforward:

1. Open the Actor in Apify Console.
2. Add one or more TikTok profile inputs.
3. Choose whether you want to scrape **Followers** or **Following**.
4. Set a maximum result count per profile, or enable **Parse all available results**.
5. Start the run.
6. Export the dataset or consume it from the Apify API.

This setup works well for both no-code users and developers. If you want a one-off export, run it manually in the UI. If you want automation, schedule runs or trigger the Actor from your application.

### Input

TikTok Followers / Following Scraper has a deliberately small input surface. Check the **Input** tab in Apify Console for field descriptions and validation.

Main input fields:

- `userQueries` - TikTok profile URLs, usernames, `@handles`, or numeric user IDs
- `relation` - choose `followers` or `following`
- `maxItems` - max number of profiles to collect per source
- `parseAll` - ignore the limit and continue pagination until finished

Example input:

```json
{
  "userQueries": [
    "https://www.tiktok.com/@taylorswift",
    "@billieeilish",
    "therock"
  ],
  "relation": "followers",
  "maxItems": 500,
  "parseAll": false
}
````

### Output

Each dataset item represents one scraped TikTok profile from the selected followers or following list. You can download the dataset extracted by TikTok Followers / Following Scraper in various formats such as **JSON, HTML, CSV, or Excel**.

Example output:

```json
[
  {
    "relation": "followers",
    "input": "https://www.tiktok.com/@taylorswift",
    "sourceUserId": "107955",
    "sourceUserType": "unique_id",
    "sourceUserValue": "taylorswift",
    "position": 1,
    "data": {
      "unique_id": "exampleuser",
      "nickname": "Example User",
      "avatar": "https://example.com/avatar.jpg",
      "sec_uid": "MS4wLjABAAAA...",
      "follower_count": 12400,
      "following_count": 310,
      "favoriting_count": 1200,
      "total_favorited": 84500
    }
  }
]
```

### What data can this TikTok scraper extract?

The Actor focuses on the most useful profile-level fields from TikTok follower/following results.

| Field | Description |
| --- | --- |
| `relation` | Whether the item came from the followers or following list |
| `input` | The original profile input you submitted |
| `sourceUserId` | The resolved TikTok user ID of the source account |
| `sourceUserValue` | The original username or ID used for scraping |
| `position` | Item order in the paginated result set |
| `data.unique_id` | TikTok handle of the scraped profile |
| `data.nickname` | Display name |
| `data.avatar` | Avatar image URL |
| `data.sec_uid` | TikTok secure user identifier |
| `data.follower_count` | Follower count for that scraped profile |
| `data.following_count` | Following count for that scraped profile |
| `data.favoriting_count` | Favoriting count when available |
| `data.total_favorited` | Total likes/favorites when available |

### How much does it cost to scrape TikTok followers or following?

The exact cost depends on how many profiles you submit and whether you scrape only a limited sample or paginate through the full list. In practice, this Actor is easiest to control when you start with a **small `maxItems` value**, validate the output shape, and only then scale up.

For example:

- 💸 Small test runs are suitable for checking a handful of profiles
- 📦 Medium runs work well for creator research or prospecting batches
- 🏭 Larger scheduled runs are better for recurring monitoring and enrichment pipelines

Because this Actor runs on Apify, pricing is tied to your platform usage and plan. That means you can start small, estimate consumption from real runs, then scale with scheduling, API access, and integrations once the workflow is stable.

### Tips for better results

- 🎯 If you only need a sample, keep `parseAll` disabled and use `maxItems`
- ⚡ Start with one or two profiles before launching large batches
- 📚 Use `followers` for audience discovery and `following` for competitor mapping
- 🔁 Schedule repeat runs if you want to monitor network changes over time
- 🧩 Combine this Actor with the Apify API if you want to feed the data into your app or CRM

### Related TikTok Actors

If you need broader TikTok workflows, these related Actors may help:

- [TikTok Video Downloader](https://apify.com/api-ninja/tiktok-video-downloader) for downloading TikTok videos
- [TikTok Data Scraper](https://apify.com/api-ninja/tiktok-data-scraper) for broader TikTok scraping use cases beyond followers/following

### FAQ, disclaimers, and support

#### Is it legal to scrape TikTok data?

This Actor is designed to collect data that is publicly visible on TikTok profiles. It is your responsibility to use the data in compliance with applicable laws, regulations, platform terms, and any privacy obligations that apply in your jurisdiction.

#### Does this Actor scrape private followers or private accounts?

No. The Actor is intended for publicly accessible TikTok profile relationship data only.

#### Can I use this Actor without coding?

Yes. The Apify Console UI is enough for most users. If you are technical, you can also trigger runs through the API and plug the output into your own systems.

#### Where can I get help or request improvements?

If you run into issues or want additional features, use the **Issues** tab on the Actor page. Feedback is useful, especially if you have edge cases around input formats, pagination depth, or export workflows. Custom adjustments and related TikTok automation work can also be built from this Actor as a base.

# Actor input Schema

## `userQueries` (type: `array`):

Add TikTok profile URLs, usernames, @handles, or numeric user IDs. Each input is processed separately. Examples: https://www.tiktok.com/@taylorswift, @taylorswift, taylorswift, 107955

## `relation` (type: `string`):

Choose whether to collect the followers list or the following list for each provided profile.

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

Maximum number of profiles to scrape for each input. Ignored when 'Parse all available results' is enabled.

## `parseAll` (type: `boolean`):

If enabled, pagination continues until the API reports there are no more results.

## Actor input object example

```json
{
  "userQueries": [
    "https://www.tiktok.com/@taylorswift"
  ],
  "relation": "followers",
  "maxItems": 500,
  "parseAll": false
}
```

# Actor output Schema

## `results` (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 = {
    "userQueries": [
        "https://www.tiktok.com/@taylorswift"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-ninja/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 = { "userQueries": ["https://www.tiktok.com/@taylorswift"] }

# Run the Actor and wait for it to finish
run = client.actor("api-ninja/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 '{
  "userQueries": [
    "https://www.tiktok.com/@taylorswift"
  ]
}' |
apify call api-ninja/tiktok-followers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Followers Scraper",
        "description": "🔥 Scrape TikTok followers or following at scale from profile URLs, @handles, or user IDs. Fast, paginated, structured, and ready for API, scheduling, and automations on Apify.",
        "version": "0.0",
        "x-build-id": "ZqgWwc0hD2R3YJ7Y5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-ninja~tiktok-followers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-ninja-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/api-ninja~tiktok-followers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-ninja-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/api-ninja~tiktok-followers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-ninja-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",
                "required": [
                    "userQueries"
                ],
                "properties": {
                    "userQueries": {
                        "title": "🔗 TikTok profile links, handles or user IDs",
                        "type": "array",
                        "description": "Add TikTok profile URLs, usernames, @handles, or numeric user IDs. Each input is processed separately. Examples: https://www.tiktok.com/@taylorswift, @taylorswift, taylorswift, 107955",
                        "items": {
                            "type": "string"
                        }
                    },
                    "relation": {
                        "title": "🗂️ What to scrape",
                        "enum": [
                            "followers",
                            "following"
                        ],
                        "type": "string",
                        "description": "Choose whether to collect the followers list or the following list for each provided profile.",
                        "default": "followers"
                    },
                    "maxItems": {
                        "title": "🔢 Max results per profile",
                        "minimum": 200,
                        "type": "integer",
                        "description": "Maximum number of profiles to scrape for each input. Ignored when 'Parse all available results' is enabled.",
                        "default": 500
                    },
                    "parseAll": {
                        "title": "♾️ Parse all available results",
                        "type": "boolean",
                        "description": "If enabled, pagination continues until the API reports there are no more results.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```