# TikTok Profile Scraper (Cheap) (`data_api/tiktok-profile-scraper-cheap`) Actor

TikTok profile scraper that pulls follower counts, stats, bio links, and avatar URLs from any public username into a ready-to-export dataset, so you stop clicking through profiles one by one.

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

## Pricing

from $3.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 Profile Insights

TikTok keeps follower counts and engagement stats locked to one profile at a time, with no export and no way to watch a list of accounts side by side. This scraper closes that gap. Hand it a list of TikTok handles and you get one tidy row per account: follower and following counts, total likes, video counts, the bio link, avatar URLs, and whether the account is verified. No login, no browser, no manual copying.

![TikTok Profile Insights](cover.jpg)

### What you get

Each handle turns into a single flat row with a steady shape, so columns line up cleanly when you load the results into a sheet or database. Three groups of data per account:

- **Identity** — `handle`, `displayName`, `accountId`, `secureId`, `bioText`, `bioUrl`, `avatarSmall`, `avatarMid`, `avatarFull`
- **Audience and activity** — `followersTotal`, `followingTotal`, `likesTotal`, `videosTotal`, `friendsTotal`, `likedVideosTotal`
- **Status and settings** — `isVerified`, `isPrivate`, `isShopSeller`, `relationStatus`, `commentPermission`, `duetPermission`, `stitchPermission`, `downloadPermission`, plus `cardTitle`, `cardSummary`, and a `collectedAt` timestamp

### Quick start

1. Hit **Try for free** and open the input form.
2. Paste your TikTok accounts into **TikTok handles or profile links** — a bare handle, an `@handle`, or a full profile link all work.
3. Press **Start**.
4. When the run finishes, export the rows as JSON, CSV, Excel, or XML.

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

### Use cases

- **Influencer vetting** — check follower counts, total likes, and video output before you reach out about a partnership
- **Competitor tracking** — watch how a rival's audience and posting cadence shift week to week
- **Creator databases** — assemble a niche list of TikTok creators with their stats and bio links in one table
- **Brand monitoring** — keep tabs on your own accounts across multiple markets on a schedule
- **Authenticity checks** — confirm an account is real, active, and verified before signing anything
- **Research datasets** — collect public profile signals for creator-recommendation or NLP projects

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `tiktokHandles` | array of strings | Yes | TikTok accounts to look up. Each entry can be a bare handle, an `@handle`, or a full profile link such as `https://www.tiktok.com/@handle`. Prefill includes `zachking` and `khaby.lame`. |

#### Example input

```json
{
    "tiktokHandles": [
        "zachking",
        "@mrbeast",
        "https://www.tiktok.com/@gordonramsayofficial"
    ]
}
````

### Output

Every handle you pass produces one row. Counts and identity fields come straight from the live profile page, and accounts that cannot be read return a row with an `errorMessage` so nothing is silently dropped.

#### Example output

```json
{
    "lookupHandle": "@zachking",
    "accountId": "6571917115348894725",
    "handle": "zachking",
    "displayName": "Zach King",
    "bioText": "Make the world a little more magic",
    "avatarSmall": "https://p16-sign-va.tiktokcdn.com/...100x100.jpeg",
    "avatarMid": "https://p16-sign-va.tiktokcdn.com/...720x720.jpeg",
    "avatarFull": "https://p16-sign-va.tiktokcdn.com/...1080x1080.jpeg",
    "bioUrl": "https://linktr.ee/zachking",
    "isVerified": true,
    "isPrivate": false,
    "secureId": "MS4wLjABAAAA...",
    "relationStatus": 0,
    "commentPermission": 0,
    "duetPermission": 0,
    "stitchPermission": 0,
    "downloadPermission": 0,
    "isShopSeller": false,
    "followersTotal": 81600000,
    "followingTotal": 51,
    "likesTotal": 945200000,
    "videosTotal": 412,
    "friendsTotal": 38,
    "likedVideosTotal": 0,
    "cardTitle": "Zach King on TikTok",
    "cardSummary": "@zachking 81.6m Followers, 51 Following, 945.2m Likes",
    "collectedAt": "2026-06-29T12:00:00+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `lookupHandle` | string | The handle or link you supplied to find this account |
| `accountId` | string | TikTok's internal numeric account ID |
| `handle` | string | The account's public @ username |
| `displayName` | string | Name shown at the top of the profile |
| `bioText` | string | The profile's bio or signature copy |
| `avatarSmall` | string | Link to the 100x100 profile picture |
| `avatarMid` | string | Link to the 720x720 profile picture |
| `avatarFull` | string | Link to the 1080x1080 profile picture |
| `bioUrl` | string | Outbound link placed in the profile bio |
| `isVerified` | boolean | True when the account shows a verification badge |
| `isPrivate` | boolean | True when the account is marked private |
| `secureId` | string | TikTok's internal secure account identifier |
| `relationStatus` | integer | Follow relationship code between the viewer and this account |
| `commentPermission` | integer | Who may comment: 0 everyone, 1 friends, 2 off |
| `duetPermission` | integer | Who may duet: 0 everyone, 1 friends, 2 off |
| `stitchPermission` | integer | Who may stitch: 0 everyone, 1 friends, 2 off |
| `downloadPermission` | integer | Whether downloads are allowed: 0 on, 1 off |
| `isShopSeller` | boolean | True when the account sells through TikTok Shop |
| `followersTotal` | integer | How many accounts follow this profile |
| `followingTotal` | integer | How many accounts this profile follows |
| `likesTotal` | integer | Sum of likes earned across every video |
| `videosTotal` | integer | Count of public videos posted |
| `friendsTotal` | integer | Number of mutual follows |
| `likedVideosTotal` | integer | How many videos this account has liked |
| `cardTitle` | string | Title from the profile's share metadata |
| `cardSummary` | string | Share-card blurb with follower, following, and like totals |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Reason an account could not be read; absent on a clean row |

### Tips for best results

- **Start with a handful.** Run five or ten handles first to confirm the output fits your pipeline before you queue up hundreds.
- **Any handle format is fine.** `zachking`, `@zachking`, and the full `https://www.tiktok.com/@zachking` link all resolve to the same account, so mix them freely.
- **Watch for `errorMessage` rows.** A private account, a typo, or a removed profile comes back as an error row with the `lookupHandle` you gave, and the run keeps going through the rest of your list.
- **Re-run on a schedule for trends.** Each run stamps `collectedAt`, so repeating the same handle list daily or weekly builds a clean growth history.
- **Read counts from the totals fields.** `followersTotal`, `likesTotal`, and `videosTotal` carry the accurate large-number values, so prefer them over the share-card summary text.

### How can I use TikTok profile data?

**How can I use TikTok Profile Insights to vet creators before a partnership?**
Paste the handles of the creators you are considering and the scraper returns each account's follower count, total likes, video count, and verification status in one table. Sort by `followersTotal` or `likesTotal` to shortlist, and check `isVerified` and `videosTotal` to confirm an account is real and active before you reach out.

**How can I track a competitor's TikTok growth over time?**
Save your input as a task and run it on a daily or weekly schedule. Every run appends fresh rows stamped with `collectedAt`, so you build a time series of `followersTotal`, `followingTotal`, and `videosTotal` for each account — useful for spotting posting streaks, follower spikes, and slowdowns.

**How can I build a TikTok creator database for a niche?**
Collect handles from your research, drop the whole list in, and export the results as CSV or Excel. You get a ready-to-filter dataset of display names, bio links, audience sizes, and engagement totals — a solid base for outreach lists, creator scoring, or recommendation research.

**How can I look up TikTok follower counts in bulk without logging in?**
This scraper reads public profile pages only, so no TikTok account or password is needed. Hand it any number of handles and it pulls the follower, following, and like totals for each one, returning a single row per account that you can export anywhere.

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

## `tiktokHandles` (type: `array`):

One or more TikTok accounts to look up. Each entry can be a bare handle, an @handle, or a full profile link such as https://www.tiktok.com/@handle — all three resolve to the same account.

## Actor input object example

```json
{
  "tiktokHandles": [
    "zachking",
    "@mrbeast",
    "https://www.tiktok.com/@gordonramsayofficial"
  ]
}
```

# 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 = {
    "tiktokHandles": [
        "zachking",
        "khaby.lame"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/tiktok-profile-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 = { "tiktokHandles": [
        "zachking",
        "khaby.lame",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/tiktok-profile-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 '{
  "tiktokHandles": [
    "zachking",
    "khaby.lame"
  ]
}' |
apify call data_api/tiktok-profile-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Profile Scraper (Cheap)",
        "description": "TikTok profile scraper that pulls follower counts, stats, bio links, and avatar URLs from any public username into a ready-to-export dataset, so you stop clicking through profiles one by one.",
        "version": "0.0",
        "x-build-id": "liCYLnyytgxYx2DT9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~tiktok-profile-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-tiktok-profile-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-profile-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-tiktok-profile-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-profile-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-tiktok-profile-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",
                "required": [
                    "tiktokHandles"
                ],
                "properties": {
                    "tiktokHandles": {
                        "title": "TikTok handles or profile links",
                        "type": "array",
                        "description": "One or more TikTok accounts to look up. Each entry can be a bare handle, an @handle, or a full profile link such as https://www.tiktok.com/@handle — all three resolve to the same account.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
