# TikTok Profile Scraper Goat (`goat255/tiktok-profile-scraper`) Actor

Scrape public TikTok profiles in bulk. Returns identity (handle, nickname, user id, avatar, bio, verified), metrics (followers, following, likes, video count), and useful account metadata. No login or cookies.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Goat - Bulk Public Profile Data, Followers, Likes & Bio

Scrape public TikTok profiles in bulk and get clean, structured data for every handle: identity, follower and like counts, video count, bio, avatar, and account metadata. No TikTok login, no cookies, no API key.

### What this TikTok profile scraper does

For each username or profile URL you pass in, the actor returns one clean row with:

- **Identity** - handle, display name, user ID, secure ID, verified badge, private flag.
- **Bio** - the profile signature plus the linked website in the bio.
- **Avatar** - the largest available profile picture URL.
- **Metrics** - followers, following, total likes (hearts), and video count.
- **Metadata** - account creation time, region, and any linked Instagram, X, or YouTube IDs the creator has set.

Returns ordered JSON that maps cleanly to CSV, Excel, or a database. Multi-source failover keeps success rates high under bulk loads.

Perfect for **influencer research, audience sizing, lead enrichment, brand monitoring, and competitor analysis**.

### Why use this TikTok profile scraper

- **No login, no cookies, no API key** - works on every public TikTok account.
- **Bulk by design** - pass hundreds of handles in one run with adjustable concurrency.
- **Flexible input** - accepts plain handles, @handles, and full profile URLs, mixed freely and auto-deduped.
- **Clean ordered output** - identity, then metrics, then metadata, ready for a spreadsheet.
- **Multi-source failover** - if one path is rate-limited, the actor falls back automatically.
- **One flat charge per profile** - you are billed once per profile scraped, never per field.

### What data you get per profile

```json
{
  "handle": "example_user",
  "nickname": "Example User",
  "userId": "000000000",
  "secUid": "MS4wLjABAAAA...",
  "verified": true,
  "privateAccount": false,
  "bio": "Just an example bio",
  "bioLink": "https://example.com",
  "avatarUrl": "https://...",
  "profileUrl": "https://www.tiktok.com/@example_user",
  "followers": 94412991,
  "following": 3,
  "likes": 459856259,
  "videoCount": 1533,
  "region": "US",
  "createdAt": 1425144149,
  "instagramId": "",
  "twitterId": "",
  "youtubeChannelId": "",
  "youtubeChannelTitle": ""
}
````

### How to use the TikTok Profile Scraper

1. Click **Try for free** on the actor page.
2. Enter TikTok **usernames** in the `usernames` input (URLs, @handles, or plain handles - all accepted).
3. Tune `concurrency` (default 4) and `delayBetweenRequests` (default 1s) for bulk runs.
4. Click **Save & start**. Download JSON / CSV / Excel / XML / HTML.

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `usernames` | string\[] | - | Handles, @handles, or full TikTok URLs (mix freely, auto-deduped) |
| `concurrency` | integer | `4` | Profiles processed in parallel |
| `delayBetweenRequests` | number | `1.0` | Seconds to wait before each profile request |
| `proxyConfiguration` | object | direct | Optional proxy settings for very large bulk runs |

### Top use cases

- **Influencer research** - size up creators by followers, likes, and video count before outreach.
- **Lead enrichment** - turn a list of TikTok handles into a structured contact and audience dataset.
- **Brand monitoring** - track follower and like growth of accounts you care about over time.
- **Competitor analysis** - benchmark your own audience metrics against profiles in your niche.
- **Audience sizing** - pull bulk metrics for media kits, reports, and pitch decks.
- **OSINT and investigations** - extract public profile identity, bio links, and cross-platform IDs.

### Integrations

#### Apify API

```bash
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=json"
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("goat255/tiktok-profile-scraper").call(run_input={
    "usernames": ["example_user_1", "@example_user_2", "https://www.tiktok.com/@example_user_3"],
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"@{item['handle']}: {item['followers']} followers, {item['videoCount']} videos")
```

#### No-code integrations

Send results directly to Google Sheets, Slack, Zapier, Make, Amazon S3, or your own webhook via [Apify Integrations](https://docs.apify.com/platform/integrations).

### Pricing

Pay-per-event. One charge per profile scraped.

| Event | Price (tiered by Apify plan) |
|---|---|
| Profile scraped (primary) | from $0.005 |

Apify subscription tiers (Bronze through Diamond) pay less per profile. Apify's $5 platform free credit applies on first use.

### FAQ

#### Do I need a TikTok account or API key?

No. The scraper works on every public TikTok profile without auth.

#### What input formats are accepted?

Plain handles (`tiktok`), @handles (`@tiktok`), and full profile URLs (`https://www.tiktok.com/@tiktok`). Mix them freely in one run.

#### Can it scrape private accounts?

Private account metrics are limited by what TikTok exposes publicly. The `privateAccount` flag tells you when a profile is private.

#### Will TikTok block this?

Multi-source failover and an adjustable request delay keep success rates high under bulk loads. Enable the proxy option for very large runs.

#### How many profiles can I scrape at once?

As many as you like. Tune `concurrency` for throughput and `delayBetweenRequests` to stay gentle under load.

### Support

Open an issue on the actor page if something breaks or a field's missing. Reviews are read and replied to.

### Related actors

Part of the scraper suite by goat255:

- [TikTok Video Scraper](https://apify.com/goat255/tiktok-video-scraper) - videos by profile or URL with full metadata.
- [TikTok Comments Scraper](https://apify.com/goat255/tiktok-comments-scraper) - comments from any TikTok video.

# Actor input Schema

## `usernames` (type: `array`):

List of public TikTok usernames or profile URLs. Mix formats freely: tiktok, @tiktok, https://www.tiktok.com/@tiktok.

## `maxVideosPerUser` (type: `integer`):

How many recent videos to collect per profile. Leave at 0 to fetch profile data only. When set, the actor walks multiple pages of the user's recent videos and emits one row per video.

## `concurrency` (type: `integer`):

Maximum number of profiles processed in parallel.

## `delayBetweenRequests` (type: `number`):

Seconds to wait before each profile request. A small delay keeps success rates high under bulk loads.

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

Optional proxy. Direct connections work for most public profiles. Enable a proxy for very large bulk runs.

## Actor input object example

```json
{
  "usernames": [
    "tiktok",
    "@example_user",
    "https://www.tiktok.com/@example_creator"
  ],
  "maxVideosPerUser": 0,
  "concurrency": 4,
  "delayBetweenRequests": 1,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "usernames": [
        "tiktok",
        "@example_user",
        "https://www.tiktok.com/@example_creator"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/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 = { "usernames": [
        "tiktok",
        "@example_user",
        "https://www.tiktok.com/@example_creator",
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Profile Scraper Goat",
        "description": "Scrape public TikTok profiles in bulk. Returns identity (handle, nickname, user id, avatar, bio, verified), metrics (followers, following, likes, video count), and useful account metadata. No login or cookies.",
        "version": "0.0",
        "x-build-id": "ugbJWFFz9FCyJZO4L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~tiktok-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-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/goat255~tiktok-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-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/goat255~tiktok-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "TikTok Usernames or URLs",
                        "type": "array",
                        "description": "List of public TikTok usernames or profile URLs. Mix formats freely: tiktok, @tiktok, https://www.tiktok.com/@tiktok.",
                        "default": [
                            "tiktok"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideosPerUser": {
                        "title": "Max Videos Per User",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many recent videos to collect per profile. Leave at 0 to fetch profile data only. When set, the actor walks multiple pages of the user's recent videos and emits one row per video.",
                        "default": 0
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of profiles processed in parallel.",
                        "default": 4
                    },
                    "delayBetweenRequests": {
                        "title": "Delay Between Requests (seconds)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Seconds to wait before each profile request. A small delay keeps success rates high under bulk loads.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy. Direct connections work for most public profiles. Enable a proxy for very large bulk runs.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
