# Tiktok Profile Scraper (`api-ninja/tiktok-profile-scraper`) Actor

🔥 Extract public TikTok profile data including user videos, favourites, followers, following, playlists, search results, and user info.

- **URL**: https://apify.com/api-ninja/tiktok-profile-scraper.md
- **Developed by:** [API ninja](https://apify.com/api-ninja) (community)
- **Categories:** Social media, Videos, Developer tools
- **Stats:** 14 total users, 13 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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 Profile Scraper do?

**TikTok Profile Scraper** extracts public profile-related data from [TikTok](https://www.tiktok.com/) by profile URL, username, handle, or numeric user ID. Use it to scrape one focused profile dataset at a time: user videos, favorite videos, followers, following, playlists, profile search results, or user profile info.

The Actor is designed for simple no-code runs in Apify Console and repeatable automated workflows through the Apify API. Because it runs on the Apify platform, you can schedule recurring TikTok profile scraping jobs, monitor runs, download datasets, connect results to integrations, and access scraped data programmatically.

### Why use TikTok Profile Scraper?

TikTok profiles contain useful public signals for creator discovery, influencer research, market monitoring, and social media analysis. This Actor helps you collect that profile data in a structured dataset without manually opening profiles and copying information.

Common use cases include:

- 📹 Tracking public videos posted by selected TikTok creators
- 👥 Building follower or following datasets for audience research
- ❤️ Reviewing public favorite videos where available
- ▶️ Extracting profile playlists for content analysis
- 👤 Collecting public profile metadata and engagement counters
- 🔍 Searching for user profiles by keyword or handle
- 📊 Exporting TikTok profile data to JSON, CSV, Excel, HTML, or API workflows

### What TikTok profile data can you extract?

The exact fields depend on the selected scrape type and on what TikTok publicly returns for a profile. The Actor keeps the output close to the source data so advanced users can work with all available fields.

| Data type       | Example fields                                                               |
| --------------- | ---------------------------------------------------------------------------- |
| User videos     | Video ID, title, description, cover image, play URL, duration, creation time |
| Video metrics   | Plays, likes, comments, shares, saves                                        |
| Creator details | Nickname, unique ID, avatar, verification status                             |
| Profile info    | Bio/signature, follower count, following count, heart count, video count     |
| Followers       | Public user objects from a profile's followers list                          |
| Following       | Public user objects from a profile's following list                          |
| Playlists       | Playlist ID, name, and available playlist metadata                           |
| Search results  | Matching public user profiles for a query                                    |

### How to scrape TikTok profile data

1. Open TikTok Profile Scraper on Apify.
2. Add one or more TikTok profile inputs in the **User URLs, usernames or IDs** field.
3. Choose one option in **What to scrape**.
4. Set **Maximum results per user**, or enable **Parse all results**.
5. Start the Actor and wait for the run to finish.
6. Open the dataset to preview, filter, download, or send the results to another tool.

You can use inputs such as:

```json
{
    "userUrls": ["https://www.tiktok.com/@taylorswift", "@billieeilish", "natgeo"],
    "scrapeType": "videos",
    "maxResults": 100,
    "scrapeAllResults": false
}
````

### Input

TikTok Profile Scraper has the following input options. Open the **Input** tab on the Actor page to edit them in a form.

| Field              | Type             | Description                                                                                           |
| ------------------ | ---------------- | ----------------------------------------------------------------------------------------------------- |
| `userUrls`         | Array of strings | TikTok profile URLs, handles, usernames, or numeric user IDs.                                         |
| `scrapeType`       | Select           | One scrape mode: videos, favorite videos, followers, following, user playlists, search, or user info. |
| `maxResults`       | Integer          | Maximum number of results per user input. Ignored when parsing all results.                           |
| `scrapeAllResults` | Boolean          | Attempts to fetch all available results for each provided user input.                                 |

Use **User Info** when you only need profile metadata. Use **User Videos**, **Followers**, **Following**, or **User Playlists** when you need lists of records from a profile.

### Output

The Actor stores results in the default Apify dataset. You can download the dataset extracted by TikTok Profile Scraper in various formats such as **JSON, HTML, CSV, or Excel**.

Example output for a video item:

```json
{
    "video_id": "7350000000000000000",
    "title": "Behind the scenes from today",
    "content_desc": "Behind the scenes from today",
    "cover": "https://...",
    "play": "https://...",
    "duration": 18,
    "play_count": 1204500,
    "digg_count": 98100,
    "comment_count": 2300,
    "share_count": 1740,
    "collect_count": 5500,
    "create_time": 1711200000,
    "author": {
        "unique_id": "creatorhandle",
        "nickname": "Creator Name",
        "avatar": "https://..."
    }
}
```

Example output for profile info:

```json
{
    "user": {
        "id": "1234567890",
        "unique_id": "creatorhandle",
        "nickname": "Creator Name",
        "signature": "Public profile bio",
        "verified": true
    },
    "stats": {
        "followingCount": 120,
        "followerCount": 2500000,
        "heartCount": 84000000,
        "videoCount": 312
    }
}
```

### How much does it cost to scrape TikTok profiles?

The final cost depends on the number of profiles, the selected scrape type, and whether you enable **Parse all results**. Profile info runs are usually small, while followers, following, favorites, and large video lists can produce many more records and take longer.

To control cost, start with a small `maxResults` value and increase it once you confirm the output matches your needs. If you need a complete dataset, enable **Parse all results**, but expect longer runs for large TikTok accounts.

### Tips and advanced options

- Use one scrape type per run to keep the dataset clean and easy to export.
- Start with **User Info** to validate that your profile inputs are correct.
- Use profile URLs when available; handles and usernames also work.
- Keep `maxResults` low for test runs, then scale up for production runs.
- Schedule the Actor to monitor the same TikTok profiles over time.
- Use the Apify API tab to integrate the Actor with Python, Node.js, Make, Zapier, Google Sheets, or your own data pipeline.

### Related TikTok Actors

If you need a different TikTok workflow, these Actors may be useful:

| Actor                                                                            | Best for                                                                                         |
| -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| [TikTok Video Downloader](https://apify.com/api-ninja/tiktok-video-downloader)   | Downloading or extracting data from specific TikTok videos                                       |
| [TikTok Followers Scraper](https://apify.com/api-ninja/tiktok-followers-scraper) | Focused follower extraction workflows                                                            |
| [TikTok Data Scraper](https://apify.com/api-ninja/tiktok-data-scraper)           | Broader TikTok scraping across profiles, comments, hashtags, music, playlists, and video details |
| [TikTok Comments Scraper](https://apify.com/api-ninja/tiktok-comments-scraper)   | Extracting comments and replies from TikTok videos                                               |

### FAQ, disclaimers, and support

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

This Actor is intended to extract publicly available TikTok data. However, your results may contain personal data because public profiles can include names, images, bios, and other user-provided information. You should only scrape and process personal data when you have a legitimate reason to do so and comply with applicable laws and platform terms. If you are unsure, consult a legal professional.

#### Does this Actor scrape private TikTok data?

No. TikTok Profile Scraper is intended for public profile data. It does not log in to private accounts or bypass access controls.

#### Why did a profile return fewer results than expected?

Some profiles, favorite lists, followers, following lists, or playlists may be private, restricted, unavailable, or limited by TikTok. Results can also vary by account settings, region, content availability, or TikTok changes.

#### Where can I get help?

Use the **Issues** tab on the Actor page to report bugs, request improvements, or describe a custom TikTok scraping workflow you need. For automation, exports, and integrations, check the Actor's **API** tab in Apify Console.

# Actor input Schema

## `userUrls` (type: `array`):

Provide TikTok profile URLs, handles, usernames, or numeric user IDs. Examples: https://www.tiktok.com/@billieeilish, billieeilish, @billieeilish, 107955

## `scrapeType` (type: `string`):

Select one profile data type to scrape for every provided user input.

## `maxResults` (type: `integer`):

Maximum number of items to fetch per user input. Ignored when 'Parse all results' is enabled.

## `scrapeAllResults` (type: `boolean`):

If enabled, the scraper ignores the result limit and attempts to fetch all available data for each user input.

## Actor input object example

```json
{
  "userUrls": [
    "https://www.tiktok.com/@taylorswift"
  ],
  "scrapeType": "videos",
  "maxResults": 100,
  "scrapeAllResults": 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 = {
    "userUrls": [
        "https://www.tiktok.com/@taylorswift"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Profile Scraper",
        "description": "🔥 Extract public TikTok profile data including user videos, favourites, followers, following, playlists, search results, and user info.",
        "version": "0.0",
        "x-build-id": "bxOxSb0RgiFHOaA5H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-ninja~tiktok-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-ninja-tiktok-profile-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-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-ninja-tiktok-profile-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-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-ninja-tiktok-profile-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": [
                    "userUrls"
                ],
                "properties": {
                    "userUrls": {
                        "title": "👥 User URLs, usernames or IDs",
                        "type": "array",
                        "description": "Provide TikTok profile URLs, handles, usernames, or numeric user IDs. Examples: https://www.tiktok.com/@billieeilish, billieeilish, @billieeilish, 107955",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeType": {
                        "title": "🗂️ What to scrape",
                        "enum": [
                            "videos",
                            "favourite_videos",
                            "followers",
                            "following",
                            "user_playlists",
                            "search",
                            "user_info"
                        ],
                        "type": "string",
                        "description": "Select one profile data type to scrape for every provided user input.",
                        "default": "videos"
                    },
                    "maxResults": {
                        "title": "Maximum results per user",
                        "minimum": 50,
                        "type": "integer",
                        "description": "Maximum number of items to fetch per user input. Ignored when 'Parse all results' is enabled.",
                        "default": 100
                    },
                    "scrapeAllResults": {
                        "title": "Parse all results",
                        "type": "boolean",
                        "description": "If enabled, the scraper ignores the result limit and attempts to fetch all available data for each user input.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
