# TikTok Profile Scraper (`santamaria-automations/tiktok-profile-scraper`) Actor

Scrape TikTok public profiles. Returns username, display name, bio, follower count, following count, like count, video count, verified status, and avatar URL. No login required. Pay-per-result.

- **URL**: https://apify.com/santamaria-automations/tiktok-profile-scraper.md
- **Developed by:** [Ale](https://apify.com/santamaria-automations) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 tiktok profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper

Pass in a list of TikTok usernames, get back their public profile data. No login, no API key, no cookies. Just HTTP.

**Immune to API signature rotation.** Most TikTok scrapers call TikTok's signed JSON API — when TikTok rotates their X-Bogus / X-Gnarly signing keys (every few months), those scrapers go dark until their owners port the new algorithm. This one parses TikTok's server-rendered HTML instead, so the signing-rotation cycle doesn't take it offline. (Caveat: if TikTok ever changes the HTML rehydration schema or gates the HTML behind a JS challenge, that's a different break — we monitor and update. The point is it's structurally independent of the signing treadmill, not invulnerable.)

This actor returns **one item per profile** — not one per video. If you want clean, structured profile metadata for lead generation, panel research, or competitor tracking, this is the right tool. If you need full video timelines, use a video scraper instead.

### What you get

For every username you pass in, the scraper hits TikTok's public profile page and pulls the rehydration block — the same JSON the TikTok webapp uses to render the profile. About **18 fields per profile**, including:

- Stable user ID + secUid (survive username changes)
- Username, display name, bio, **link in bio**
- Follower / following / video counts
- Verified badge, private flag, TikTok Shop seller flag + category
- Account language and **account creation timestamp**
- High-resolution avatar URL
- Profile URL and scrape timestamp

If TikTok soft-blocks a proxy IP mid-run, the scraper rotates to a fresh session and retries the profile (up to `maxIPRotations` times, default 5). One bad IP doesn't kill the batch.

### Input

```json
{
  "profiles": ["charlidamelio", "khaby.lame", "mrbeast"]
}
````

Usernames can be plain (`charlidamelio`), at-prefixed (`@charlidamelio`), or full URLs (`https://www.tiktok.com/@charlidamelio`). All three normalize to the same thing.

#### Available input fields

| Field | Type | Default | Description |
|---|---|---|---|
| `profiles` | array | required | Usernames, @handles, or profile URLs |
| `maxIPRotations` | integer | 5 | How many times to retry a profile with a fresh session if TikTok soft-blocks the IP |
| `proxyConfiguration` | object | RESIDENTIAL | Apify proxy. Residential strongly recommended — TikTok rate-limits datacenter IPs hard |

### Output

One item per profile.

```json
{
  "username": "charlidamelio",
  "user_id": "5831967",
  "sec_uid": "MS4wLjABAAAA-VASjiXTh7wDDyXvjk10VFhMWUAoxr8bgfO1kAL1-9s",
  "display_name": "charli d'amelio",
  "bio": null,
  "bio_link": "https://youtube.com/@charlidamelio",
  "follower_count": 158300000,
  "following_count": 1394,
  "like_count": null,
  "video_count": 3154,
  "verified": true,
  "is_private": false,
  "is_seller": false,
  "commerce_category": null,
  "language": "en",
  "account_created_at": "2015-11-14T12:57:18Z",
  "avatar_url": "https://p16-common-sign.tiktokcdn-eu.com/tos-maliva-avt-0068/...",
  "profile_url": "https://www.tiktok.com/@charlidamelio",
  "scraped_at": "2026-06-12T06:13:15Z"
}
```

#### A few notes about the fields

- `user_id` is the stable numeric ID. Use it as a primary key — TikTok usernames can change but IDs cannot.
- `bio_link` is the URL the creator placed in their bio (Linktree, YouTube, store, Instagram, etc.). Null when they haven't set one. **This is usually the most valuable field for lead generation.**
- `is_seller` + `commerce_category` flag TikTok Shop sellers. Filter on these to build a panel of creators with monetised shops.
- `account_created_at` is useful for trust scoring — brand-new accounts are higher risk for bot/spam analyses.
- `like_count` (total likes across all videos) is sometimes `null`. TikTok has been quietly removing this from the public profile payload for some accounts — when it's there we return it, when it isn't we set null instead of guessing.
- `follower_count`, `following_count`, `video_count` are integers, not the abbreviated "158.3M" strings you see on the page.
- `verified` is the blue check.
- `bio` is `null` if the profile has no bio set.
- `avatar_url` is the highest-resolution variant TikTok exposes (usually 1080×1080).

### Examples

**Single profile**

```json
{"profiles": ["charlidamelio"]}
```

**Mixed input formats**

```json
{
  "profiles": [
    "charlidamelio",
    "@khaby.lame",
    "https://www.tiktok.com/@mrbeast"
  ]
}
```

**Competitor or influencer panel**

```json
{
  "profiles": ["nike", "adidas", "newbalance", "puma"],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**TikTok Shop seller research**

Pass in a list of usernames, then filter the dataset by `is_seller: true` to get only the creators with monetised shops, along with their `commerce_category`.

### Pricing

Pay per result.

| Event | Price |
|---|---|
| Actor start | $0.005 |
| Each profile delivered | $0.0005 |

Some quick math:

- 10 profiles = **$0.010** total
- 100 profiles = **$0.055** total
- 1,000 profiles = **$0.505** total

No monthly fees. No minimum spend. You only pay for profiles the scraper actually returns — if TikTok blocks a profile and we can't recover it, you aren't charged for that profile.

### How to use it from an AI agent

The actor is exposed on Apify's MCP endpoint:

```
https://mcp.apify.com?tools=santamaria-automations/tiktok-profile-scraper
```

This works with Claude Desktop, Claude.ai, Cursor, VS Code, LangChain, and any other MCP client.

Example prompt:

> Use tiktok-profile-scraper to get profile data for charlidamelio, khaby.lame, and mrbeast. Show me a table of follower count, bio link, and account age, sorted by follower count.

### Caveats

- Only public accounts can be scraped. Private accounts return basic profile fields with `is_private: true` and most stats null.
- `like_count` and `bio` may be `null` even for big accounts — TikTok doesn't always expose those fields in the public payload.
- Avatar URLs are signed and expire after a few months. Re-scrape if you need fresh ones.
- Residential proxy is strongly recommended. Datacenter IPs work occasionally but TikTok blocks them aggressively.

### Issues, feature requests

- [Issues tab on the actor page](https://apify.com/santamaria-automations/tiktok-profile-scraper/issues)
- [Other actors by santamaria-automations](https://apify.com/santamaria-automations)

# Actor input Schema

## `profiles` (type: `array`):

Public TikTok accounts to scrape. Accepts plain usernames ('charlidamelio'), @-prefixed handles ('@charlidamelio'), or full profile URLs ('https://www.tiktok.com/@charlidamelio'). Private accounts are skipped.

## `maxIPRotations` (type: `integer`):

How many times to retry a profile with a fresh proxy session if TikTok soft-blocks the current IP. Higher values cost slightly more on retries but recover more profiles in heavy runs.

## `proxyConfiguration` (type: `object`):

Apify proxy. Datacenter (BUYPROXIES94952) works fine for this scraper — TikTok serves the public profile HTML without rate-limiting datacenter IPs at the volumes we use. Switch to RESIDENTIAL only if datacenter is degraded for a specific run.

## Actor input object example

```json
{
  "profiles": [
    "charlidamelio",
    "khaby.lame",
    "mrbeast"
  ],
  "maxIPRotations": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

## `profiles` (type: `string`):

Dataset containing scraped TikTok profile data

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

// Run the Actor and wait for it to finish
const run = await client.actor("santamaria-automations/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 = { "profiles": [
        "charlidamelio",
        "khaby.lame",
        "mrbeast",
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Profile Scraper",
        "description": "Scrape TikTok public profiles. Returns username, display name, bio, follower count, following count, like count, video count, verified status, and avatar URL. No login required. Pay-per-result.",
        "version": "1.6",
        "x-build-id": "cxmeXb4jqQG2VlbjC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/santamaria-automations~tiktok-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-santamaria-automations-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/santamaria-automations~tiktok-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-santamaria-automations-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/santamaria-automations~tiktok-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-santamaria-automations-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": [
                    "profiles"
                ],
                "properties": {
                    "profiles": {
                        "title": "TikTok usernames or profile URLs",
                        "type": "array",
                        "description": "Public TikTok accounts to scrape. Accepts plain usernames ('charlidamelio'), @-prefixed handles ('@charlidamelio'), or full profile URLs ('https://www.tiktok.com/@charlidamelio'). Private accounts are skipped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxIPRotations": {
                        "title": "Max IP rotations per profile",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many times to retry a profile with a fresh proxy session if TikTok soft-blocks the current IP. Higher values cost slightly more on retries but recover more profiles in heavy runs.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Datacenter (BUYPROXIES94952) works fine for this scraper — TikTok serves the public profile HTML without rate-limiting datacenter IPs at the volumes we use. Switch to RESIDENTIAL only if datacenter is degraded for a specific run.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "BUYPROXIES94952"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```