# TikTok Followers Scraper (Cheap) (`data_api/tiktok-followers-scraper-cheap`) Actor

TikTok follower count scraper that pulls followers, following, likes, and video stats for any public username, so you don't have to look them up by hand.

- **URL**: https://apify.com/data\_api/tiktok-followers-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 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

## TikTok Follower Stats Scraper

![TikTok Follower Stats Scraper](cover.jpg)

Checking a creator's follower count by hand means opening the app, finding the profile, and reading numbers that round off the moment they pass a few thousand. Do that across a roster of accounts and your afternoon is gone. This scraper takes a TikTok handle, or a whole list of them, and gives back the exact follower count, following total, lifetime likes, video count, join date, and verified status as fields you can drop straight into a sheet. One profile or a few hundred, every row has the same shape.

### What you get

One record per handle, always with the same set of fields. When a value is not available it comes back as `null` rather than disappearing, so your columns line up when you load the data into a spreadsheet or database. Each row covers:

- **Identity** — `accountHandle`, `accountName`, `isVerified`
- **Audience and activity** — `followerCount`, `followingCount`, `likeCount`, `videoCount`
- **Account history** — `joinedDate`, `collectedAt`, plus `errorMessage` if a handle could not be read

### Quick start

1. Click **Try for free** to open the input form.
2. Type a single handle into **Single handle**, or paste a batch into **Handle list** (the @ is optional either way).
3. Set a **Results limit** if you want to cap the run, and raise **Timeout (seconds)** if requests are slow.
4. Hit **Start**, then export the results as JSON, CSV, Excel, or XML once the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Influencer vetting** — pull follower and like counts for a shortlist before signing a partnership
- **Growth tracking** — run the same handles on a schedule and watch how counts move week to week
- **Competitor benchmarking** — line up your follower and video totals against rival creators in your niche
- **Agency reporting** — refresh client roster stats in one run instead of checking each profile by hand
- **Audience research** — size up creators in a category before planning a campaign or outreach list

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `profileUsername` | string | One of `profileUsername` or `profileUsernames` | A single TikTok handle to look up. The leading @ is optional. |
| `profileUsernames` | array of strings | One of `profileUsername` or `profileUsernames` | A batch of handles for one run. The @ is optional on each entry. |
| `resultsLimit` | integer | No | Cap on how many handles to process per run. Default `50`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before timing out. Default `45`. |

#### Example input

```json
{
    "profileUsername": "tiktok",
    "profileUsernames": ["khaby.lame", "bellapoarch"],
    "resultsLimit": 50,
    "timeoutSeconds": 45
}
````

### Output

Every handle you pass produces one row, and every field is always present — values that could not be read come back as `null` so your dataset stays rectangular.

#### Example output

```json
{
    "accountHandle": "tiktok",
    "accountName": "TikTok",
    "followerCount": 81500000,
    "followingCount": 12,
    "likeCount": 412000000,
    "videoCount": 640,
    "joinedDate": "2016-05-19T00:00:00.000Z",
    "isVerified": true,
    "collectedAt": "2026-06-30T12:00:00+00:00",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `accountHandle` | string | The TikTok handle that was looked up |
| `accountName` | string | Public display name on the profile |
| `followerCount` | integer | Number of followers the account has |
| `followingCount` | integer | Number of accounts the profile follows |
| `likeCount` | integer | Total likes across all of the account's videos |
| `videoCount` | integer | Count of videos posted |
| `joinedDate` | string | Date the account was created, ISO 8601 |
| `isVerified` | boolean | True when the profile carries a verified badge |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Reason a handle failed; `null` on success |

### Tips for best results

- **Start with a couple of handles.** Confirm the output fits your pipeline before pushing a long list through.
- **Drop the @ or keep it.** Both `@khaby.lame` and `khaby.lame` resolve the same way, so paste handles however you have them.
- **Use `resultsLimit` to control spend.** Keep it low while testing, then raise it for the full batch.
- **One bad handle won't sink the run.** Private, deleted, or mistyped accounts return a row with `errorMessage` set and the run keeps going.
- **Raise `timeoutSeconds` to about 60** if you see frequent timeouts on larger batches.

### How can I use TikTok follower data?

**How can I use the TikTok Follower Stats Scraper to vet influencers before a deal?**
Paste the handles on your shortlist into **Handle list** and run them in one pass. Each creator comes back with their follower count, like total, video count, and verified status, so you can compare reach side by side and flag inflated or inactive accounts before any contract is signed.

**How can I track TikTok follower growth over time?**
Run the same set of handles on a schedule and keep the dated rows. Because every record carries `followerCount`, `likeCount`, and a `collectedAt` timestamp, you can chart how each account climbs or stalls across weeks without opening the app once.

**How can I pull follower counts for a list of TikTok creators at once?**
Feed the whole list into `profileUsernames` and set `resultsLimit` to cover it. Every handle returns one row with the same fields, turning a pile of usernames into a tidy table you can export to CSV or Excel and hand straight to your team.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `profileUsername` (type: `string`):

One TikTok handle to look up. Typing the leading @ is fine but not needed.

## `profileUsernames` (type: `array`):

A batch of TikTok handles to pull stats for in one run. The @ prefix is optional on every entry.

## `resultsLimit` (type: `integer`):

Most handles to run through in a single pass. Handy for trimming spend on test runs.

## `timeoutSeconds` (type: `integer`):

How long to wait on each request before giving up. Bump it up if you hit frequent timeouts.

## Actor input object example

```json
{
  "profileUsername": "tiktok",
  "profileUsernames": [
    "khaby.lame",
    "bellapoarch"
  ],
  "resultsLimit": 50,
  "timeoutSeconds": 45
}
```

# 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 = {
    "profileUsername": "kawsarlog"
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/tiktok-followers-scraper-cheap").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 = { "profileUsername": "kawsarlog" }

# Run the Actor and wait for it to finish
run = client.actor("data_api/tiktok-followers-scraper-cheap").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 '{
  "profileUsername": "kawsarlog"
}' |
apify call data_api/tiktok-followers-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Followers Scraper (Cheap)",
        "description": "TikTok follower count scraper that pulls followers, following, likes, and video stats for any public username, so you don't have to look them up by hand.",
        "version": "0.0",
        "x-build-id": "h94csXQiscToKYDdr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~tiktok-followers-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-tiktok-followers-scraper-cheap",
                "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/data_api~tiktok-followers-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-tiktok-followers-scraper-cheap",
                "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/data_api~tiktok-followers-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-tiktok-followers-scraper-cheap",
                "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": {
                    "profileUsername": {
                        "title": "Single handle",
                        "type": "string",
                        "description": "One TikTok handle to look up. Typing the leading @ is fine but not needed."
                    },
                    "profileUsernames": {
                        "title": "Handle list",
                        "type": "array",
                        "description": "A batch of TikTok handles to pull stats for in one run. The @ prefix is optional on every entry.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "Results limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Most handles to run through in a single pass. Handy for trimming spend on test runs.",
                        "default": 50
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each request before giving up. Bump it up if you hit frequent timeouts.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
