# TikTok Followers Scraper: Followers & Following, $0.3/1K (`transparent_meteorite/tiktok-followers-scraper`) Actor
Export the follower list and following list of public TikTok profiles with username, nickname, user ID, verified badge, bio, follower, following, like and video counts. No login, no cookies.
- **URL**: https://apify.com/transparent_meteorite/tiktok-followers-scraper.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.30 / 1,000 follower or followings
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 Followers Scraper: followers and following lists
[](https://console.apify.com/actors/LD4X5kZAuuN31AHXN/input)
| Price per 1,000 profiles | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$0.70** | **$0.70** | **$0.60** | **$0.30** |
| Most-used alternative | $1.00 | $1.00 | $1.00 | $1.00 |
Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-15; check the Pricing tab for the current figure.
Turn any public TikTok profile into a table of its followers, or of the accounts it follows: username, display name, user ID, verified badge, bio, and each account's follower, following, like and video counts. Paste usernames or profile URLs. No login, no cookies, no TikTok account.
- **In short:** TikTok Followers Scraper (Apify actor `transparent_meteorite/tiktok-followers-scraper`) reads the follower list and the following list of public TikTok profiles and returns one row per account.
- **Who it is for:** influencer marketing (audience quality, fake-follower checks), brands sizing a competitor's audience, agencies building creator lists, researchers mapping networks.
- **Input:** profiles (usernames or URLs); followers per profile; following per profile; max rows; proxy.
- **Output:** 18 fields per row: type (follower or following), uniqueId, nickname, id, secUid, profileUrl, verified, privateAccount, signature (bio, contact details removed), avatar, followerCount, followingCount, heartCount, videoCount, sourceProfile. JSON, CSV or Excel.
- **Pricing:** pay per event. Per row delivered: $0.0007 free plan, $0.0007 Bronze, $0.0006 Silver, $0.0003 Gold, Platinum and Diamond. Start event $0.00005 per GB of run memory.
- **Limits:** TikTok lets logged-out visitors page through a capped part of a big account's follower list (see Limits); following lists are complete unless the creator hides them.
**Paste a username, press Start, get its followers as a table in under a minute.**
### Run in 30 seconds
1. Open the actor in [Apify Console](https://console.apify.com/actors?search=transparent_meteorite%2Ftiktok-followers-scraper) (a free Apify account is enough).
2. Press **Start** with the prefilled input: 50 followers and 50 followed accounts of @natgeo, about $0.10 on the free plan.
3. Open the **Output** tab: the **Followers** view is a table. Download as CSV, Excel or JSON.
```json
{
"profiles": ["natgeo"],
"maxFollowersPerProfile": 50,
"maxFollowingPerProfile": 50
}
```
An empty input `{}` also works: it reads 100 followers of @natgeo.
### Why choose this over alternatives
| | This actor | Typical TikTok follower scrapers |
|---|---|---|
| Price per row (free plan) | **$0.0007** | $0.001 |
| Price per row (Gold, Platinum, Diamond) | **$0.0003** | $0.001 |
| Start fee | **$0.00005 per GB** | up to $0.001 |
| Followers and following in one run | **Yes** | Often separate runs |
| Follower, like and video counts of every account | **Yes** | Yes |
| Contact details removed from bios | **Yes** | No |
| Profiles that cannot be read | **Not charged** | Varies |
### What you get: output fields
| Field | Meaning |
|---|---|
| `type` | `follower` (follows the source profile) or `following` (followed by it) |
| `uniqueId`, `nickname`, `id`, `secUid` | Username, display name and IDs |
| `profileUrl`, `avatar` | Profile link and avatar image |
| `verified`, `privateAccount` | Verified badge, private account |
| `signature` | Bio, with e-mail addresses and phone numbers removed |
| `bioLink` | Link in bio: TikTok's bio link, or the first web link written in the bio |
| `hasActiveStory` | true while the account has a live TikTok Story |
| `followerCount`, `followingCount`, `heartCount`, `videoCount`, `diggCount` | The account's followers, following, likes received, videos, videos liked |
| `sourceProfile`, `sourceProfileUrl` | Which profile's list the row came from |
| `scrapedAt` | Read time |
Sample row:
```json
{
"type": "follower",
"uniqueId": "lefaucon130",
"verified": false,
"privateAccount": false,
"followerCount": 1070,
"followingCount": 2055,
"heartCount": 367,
"videoCount": 16,
"sourceProfile": "natgeo",
"profileUrl": "https://www.tiktok.com/@lefaucon130"
}
```
### Input options
- `profiles`: usernames (`natgeo`, `@natgeo`) or `https://www.tiktok.com/@natgeo` URLs.
- `maxFollowersPerProfile` (default 100): followers per profile, newest first. 0 skips followers.
- `maxFollowingPerProfile` (default 0): followed accounts per profile. 0 skips the following list.
- `maxItems`: hard cap across the run. A run also stops at your **Max cost per run** setting.
- `proxyConfiguration`: Apify datacenter proxy by default; the actor moves to residential by itself if sessions keep failing.
### Pricing
Pay per event. No subscription, no rental fee.
| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Row (one follower or followed account) | $0.0007 | $0.0007 | $0.0006 | $0.0003 | $0.0003 | $0.0003 |
| Rows | Free | Bronze | Silver | Gold+ |
|---|---|---|---|---|
| 1,000 | $0.95 | $0.80 | $0.60 | $0.30 |
| 10,000 | $9.50 | $8 | $6 | $3 |
Not charged: profiles that cannot be read, private accounts, and hidden following lists.
### How to run it
- **Console:** fill the form, press Start.
- **API:** `POST https://api.apify.com/v2/acts/transparent_meteorite~tiktok-followers-scraper/run-sync-get-dataset-items?token=` with the input JSON as the body.
- **Python:** `ApifyClient(token).actor("transparent_meteorite/tiktok-followers-scraper").call(run_input={"profiles": ["natgeo"], "maxFollowersPerProfile": 1000})`
### Limits and honest caveats
- **Follower lists of big accounts may be capped by TikTok.** Logged-out visitors see followers newest first, and TikTok can end the list early on very large accounts. In our test (13 Oct 2026) @natgeo's follower list paged to 7,000 followers with no cap and no duplicates, and the full following lists of @natgeo (62) and @khaby.lame (81) came back complete. We don't promise more than that. The log and the `OUTPUT` record say where TikTok's list ended, so you never pay for rows that do not exist.
- Following lists come back complete in our tests (62 of 62 for @natgeo, 81 of 81 for @khaby.lame). Some creators hide their following list; those return 0 rows and cost nothing.
- Private accounts do not show their lists to visitors.
- The actor runs a real headless browser so TikTok's own page code signs each request; about 30 accounts per request, roughly 7 rows per second.
### Example workflows
**Influencer vetting.** Before paying a creator, read a few hundred of their followers with `maxFollowersPerProfile` set to 300. Look at `videoCount`, `heartCount` and `followerCount` on each follower row. A healthy audience mixes active accounts with real posting history; a list full of accounts with zero videos, zero likes and no bio deserves a closer look. Because every row carries these counts, you can compute the share of empty accounts in a spreadsheet in a minute.
**Competitor audience sizing.** Put several competitor brands into `profiles` and read a sample of followers from each. Compare how many followers are verified, how many are creators with large audiences of their own, and how the follower counts of the audience are distributed. Run the same task every month to see whether the make-up of an audience changes.
**Creator and partner discovery.** Switch on the following list with `maxFollowingPerProfile`. The accounts a brand or a creator follows are often their partners, ambassadors, suppliers and peers. A single run over a well-connected account gives you a ready shortlist, each with a profile link, bio, verified badge and follower count.
**Network mapping for research.** Researchers can read the lists of a seed set of accounts and then feed the discovered usernames back into `profiles` for a second round. Each row stores `sourceProfile`, so you can rebuild who follows whom from the exported file in any graph tool.
**Lead and community lists.** Community managers can export the newest followers of their own account to see who just joined, and agencies can build lists of creators in a niche by reading the following list of a niche hub account.
### Input reference
| Field | Type | Default | What it does |
|---|---|---|---|
| `profiles` | list of text | `natgeo` | Usernames, usernames with an at sign, or full profile URLs of public accounts. Mix the formats freely. |
| `maxFollowersPerProfile` | number | 100 | How many followers to read per profile, newest first. 0 skips followers entirely. |
| `maxFollowingPerProfile` | number | 0 | How many followed accounts to read per profile. 0 skips the following list. |
| `maxItems` | number | no cap | Hard stop for the whole run across all profiles. |
| `proxyConfiguration` | object | Apify proxy | Datacenter proxy by default. The actor switches to residential on its own if sessions keep failing. |
An empty input `{}` is valid and returns 100 followers of the example profile, which makes it a safe first test.
### Output reference
Each row is one account and is tagged with the list it came from. The `type` field is either `follower` or `following`, and `sourceProfile` tells you whose list the row belongs to. The account itself is described by its username (`uniqueId`), display name (`nickname`), numeric `id` and `secUid`, a ready-made `profileUrl`, the `avatar` link, the `verified` and `privateAccount` flags, and the bio in `signature`. Four counters complete the picture: `followerCount`, `followingCount`, `heartCount` (likes received) and `videoCount`. The data is available in the Output tab as a table and can be downloaded as JSON, CSV, Excel, XML or HTML, or pulled through the Apify API.
### Tips for reliable, low-cost runs
- Start small. Run 20 followers first to check the fields you need, then raise the limit.
- Set **Max cost per run** in the run options when you schedule large jobs. The actor stops cleanly when the budget is used up and keeps every row collected so far.
- Use `maxItems` when you feed many profiles, so one very large account cannot use the whole budget.
- Read followers and following in the same run and keep both lists from the same moment.
- Schedule weekly runs and compare files to see who followed or unfollowed. Newest-first order makes the top of the list the interesting part for a recurring check.
- Remember that a run on a private account returns nothing and costs nothing.
### More questions
**How many followers can I get from one account?** The actor pages through the list for as long as TikTok serves it to a logged-out visitor. The log and the `OUTPUT` record state where the list ended, and you only pay for rows that were delivered.
**Are the rows in a fixed order?** Followers arrive newest first, following lists in the order TikTok returns them.
**Can I run many profiles at once?** Yes. Put as many profiles as you like in `profiles` and set `maxItems` to protect your budget.
**Is the data fresh?** Every row carries `scrapedAt`, and counters are read at the moment of the run.
**Which export formats are supported?** JSON, CSV, Excel, XML and HTML from the Output tab, plus the dataset API and integrations such as Google Sheets, Make, Zapier and webhooks.
**What about duplicate rows?** Accounts are de-duplicated inside a run, so the same follower is not charged twice.
**Can I use it on a schedule?** Yes. Create a task, set a schedule in Apify and connect the result to a webhook or to your own storage.
### FAQ
**Do I need a TikTok account or cookies?** No.
**Can I check if an influencer's followers are real?** Yes: read a sample of followers and look at `followerCount`, `videoCount` and `heartCount`; many accounts with 0 videos and 0 likes is a warning sign.
**Do you return e-mails or phone numbers?** No. Followers are mostly private people, so contact details are removed from bios.
**What does a failed profile cost?** Nothing. Only delivered rows are charged.
### Use it from AI assistants (MCP)
TikTok Followers Scraper works as a tool for AI assistants through the official Apify MCP server. Add this URL to any MCP client (Claude Desktop, Claude Code, Cursor, ChatGPT connectors, VS Code):
```
https://mcp.apify.com/?actors=transparent_meteorite/tiktok-followers-scraper
```
Then ask, for example: "Get 500 followers of @duolingo and tell me what share of them have never posted a video."
### Terms and responsible use
The actor reads only lists TikTok shows publicly to logged-out visitors and removes contact details from bios. You are responsible for using the data lawfully (GDPR, CCPA, TikTok's terms). Do not use it for spam, harassment or unsolicited messaging.
### Changelog
- 0.1 (2026-10-13): first release. Followers and following lists, counts per account, contact details removed from bios.
### Support
Found a bug or need a field? Open an issue on the Issues tab with the run URL. We reply there.
New to Apify? [Create a free account](https://console.apify.com/sign-up?fpr=rnmakg) and run this Actor in under a minute. Some links are affiliate links.
# Actor input Schema
## `profiles` (type: `array`):
Usernames (natgeo, @natgeo) or profile URLs (https://www.tiktok.com/@natgeo) of public TikTok accounts.
## `maxFollowersPerProfile` (type: `integer`):
Maximum followers to read for each profile, newest first (0 = skip followers). See the README for how far TikTok lets visitors scroll.
## `maxFollowingPerProfile` (type: `integer`):
Maximum accounts each profile follows to read (0 = skip). Some creators hide their following list; those return 0 rows and are not charged.
## `maxItems` (type: `integer`):
Stop after this many rows across all profiles.
## `proxyConfiguration` (type: `object`):
Apify datacenter proxy works; the actor switches to residential by itself if a session keeps failing.
## Actor input object example
```json
{
"profiles": [
"natgeo"
],
"maxFollowersPerProfile": 50,
"maxFollowingPerProfile": 50,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `overview` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"profiles": [
"natgeo"
],
"maxFollowersPerProfile": 50,
"maxFollowingPerProfile": 50,
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"profiles": ["natgeo"],
"maxFollowersPerProfile": 50,
"maxFollowingPerProfile": 50,
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/tiktok-followers-scraper").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 '{
"profiles": [
"natgeo"
],
"maxFollowersPerProfile": 50,
"maxFollowingPerProfile": 50,
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call transparent_meteorite/tiktok-followers-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/tiktok-followers-scraper"
}
}
}
```
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 ` 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/LD4X5kZAuuN31AHXN/builds/OLV9x8h3PylraDuBP/openapi.json