# Tiktok Comments Scraper ($0.20 Per 1K) (`kawsar/tiktok-comments-scraper`) Actor
TikTok comment scraper that pulls comments and replies from any public post, so researchers and marketers get usable data without copying a single comment by hand.
- **URL**: https://apify.com/kawsar/tiktok-comments-scraper.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet
## Pricing
$0.20 / 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.
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 Comment Scraper: Extract comments and replies from any TikTok post
The most affordable TikTok comment scraper you'll find. Point it at one post or a hundred and you get a clean dataset: comments, replies, usernames, like counts, timestamps, and the total count per search query. Export it or feed it into whatever tool you're using.
Copying TikTok comments by hand breaks fast. After 30 rows you're losing your mind. This actor hits TikTok's internal comment API and pulls thousands of records in minutes, nested replies included, no browser or login needed.
### Why you need a TikTok comment scraper
TikTok comments are where real audience reactions live, not the like count (vanity) or the view count (reach), but the text people type when they feel strongly enough to say something.
Without a scraper you're reading one comment at a time. With one, you can run sentiment analysis, spot recurring topics, track how a conversation shifts over 24 hours, or build a training dataset in an afternoon instead of a week.
### Use cases
- Collect comments from brand posts to measure how audiences react over time
- Scrape comments on a competitor's top videos to see what their audience actually asks for
- Track which posts generate the most discussion and what topics keep surfacing
- Build labeled comment datasets for hate speech detection, topic modeling, or text classification
- Pull comment data before signing a creator deal to check authenticity
- Schedule runs to collect new comments from the same posts automatically over time
### Input
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `postUrls` | array | — | TikTok post URLs to scrape. Supports video posts, photo posts, and short links (vm.tiktok.com). Required. |
| `maxCommentsPerPost` | integer | 100 | Maximum comments to collect per URL. Set up to 100,000 to scrape everything available. |
| `includeReplies` | boolean | true | When enabled, fetches replies nested under each comment. |
| `maxRepliesPerComment` | integer | 50 | Maximum replies per comment. Only applies when reply fetching is enabled. |
| `timeoutSecs` | integer | 300 | Total actor run time in seconds. Max 3,600. |
| `requestTimeoutSecs` | integer | 30 | Timeout per individual request to TikTok. |
| `proxyConfiguration` | object | Datacenter (Anywhere) | Proxy type and location for requests. Supports Datacenter, Residential, Special, and custom proxies. Optional. |
#### Example input
```json
{
"postUrls": [
"https://www.tiktok.com/@bellapoarch/video/6862153058223197445",
"https://www.tiktok.com/@charlidamelio/video/7084020840384219398"
],
"maxCommentsPerPost": 500,
"includeReplies": true,
"maxRepliesPerComment": 50,
"proxyConfiguration": { "useApifyProxy": true }
}
````
### What data does this actor extract?
One row per comment. Replies are embedded as an array inside each comment row, so you get the full thread in one record without separate reply rows cluttering your dataset.
Example record:
```json
{
"searchQuery": "https://www.tiktok.com/@bellapoarch/video/6862153058223197445",
"awemeId": "6862153058223197445",
"commentId": "7630580008846721805",
"username": "john_doe99",
"nickname": "John Doe",
"commentText": "This is so funny lmao 😂",
"likeCount": 6,
"replyCount": 2,
"commentLanguage": "en",
"isAuthorPinned": false,
"createdAt": "2020-08-16T14:22:05+00:00",
"replies": [
{
"commentId": "7630590001234567890",
"username": "jane_smith",
"nickname": "Jane Smith",
"commentText": "Same lmao 😂",
"likeCount": 3,
"commentLanguage": "en",
"createdAt": "2020-08-16T15:10:00+00:00",
"scrapedAt": "2026-04-20T10:15:00+00:00"
}
],
"scrapedAt": "2026-04-20T10:15:00+00:00"
}
```
| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | The post URL used as input |
| `awemeId` | string | TikTok internal post ID from the URL |
| `commentId` | string | Unique comment identifier (`cid` from TikTok API) |
| `username` | string | TikTok username (`unique_id`) of the commenter |
| `nickname` | string | Display name of the commenter |
| `commentText` | string | Full text of the comment |
| `likeCount` | integer | Likes on this comment (`digg_count` from TikTok API) |
| `replyCount` | integer | Total replies this comment has (`reply_comment_total` from API) |
| `commentLanguage` | string | Language code detected by TikTok (e.g. `en`, `es`, `fr`) |
| `isAuthorPinned` | boolean | True if the post author pinned this comment |
| `createdAt` | string | ISO 8601 timestamp of when the comment was posted |
| `replies` | array | Embedded reply objects. Each has `commentId`, `username`, `nickname`, `commentText`, `likeCount`, `commentLanguage`, `createdAt`, `scrapedAt`. Empty array when no replies or replies are disabled. |
| `scrapedAt` | string | ISO 8601 timestamp of when this record was scraped |
#### Sample results — table view
#### Sample results — JSON view
### How it works
1. The actor resolves each input URL, following redirects for short links like vm.tiktok.com
2. It pulls the TikTok post ID (`aweme_id`) from the final URL
3. It pages through TikTok's internal comment API until it hits your limit
4. For each comment, replies are fetched immediately and embedded into that comment's row
5. Each comment row is pushed to the dataset as soon as it is ready, so data appears in real time
### Scheduling: watch TikTok posts for new comments over time
You can put this on a repeating schedule using Apify's built-in scheduler. Set it to run every hour, every day, whatever fits, and it will collect new comments from the same posts each time without you touching anything.
To schedule a run:
1. Click "Save as a new task" after setting up your input
2. Open the "Schedule" tab
3. Pick your interval (every 6 hours is a reasonable starting point)
4. It runs on its own and appends new results to the dataset
Good for watching how reactions shift after a launch, tracking a viral post as comments pile up, or monitoring a creator you work with without opening the app.
### Video walkthrough
For a quick demo of how to configure and run the actor, see the Apify platform video guides at [docs.apify.com](https://docs.apify.com).
### FAQ
**Can this scrape comments from private TikTok accounts?**
No. Public posts only. Private accounts and age-restricted content need a login, which this actor does not use.
**What about short links like vm.tiktok.com?**
Handled automatically. The actor follows the redirect and pulls the post ID from wherever it lands.
**How many comments can I get per run?**
Up to 100,000 per post URL. Set `maxCommentsPerPost` to whatever limit you need. Most use cases land between 100 and 5,000, but viral posts can have far more and the actor will keep paginating until it hits your limit.
**Will TikTok block the requests?**
TikTok does rate-limit scrapers. Apify's proxy (on by default) cuts that risk considerably. If you still hit walls, Residential proxies in the settings usually fix it.
**What does the `count` field mean?**
It is the total number of records (comments plus replies) collected for that post URL in a single run. Every row for the same URL will have the same `count` value, making it easy to group results by source post.
**Can I get data from multiple posts in one run?**
Yes. Add as many TikTok URLs as you need, one per line. Each URL gets its own `searchQuery` and `count` in the output.
### Integrations
Connect with other apps via [Apify integrations](https://apify.com/integrations): Google Sheets, Slack, Make, Zapier, and more. Set up [webhooks](https://docs.apify.com/integrations/webhooks) to trigger the next step in your workflow the moment a run finishes.
# Actor input Schema
## `postUrls` (type: `array`):
List of TikTok post URLs to scrape comments from. Supports video posts, photo posts, and short links (vm.tiktok.com).
## `maxCommentsPerPost` (type: `integer`):
Maximum number of comments to collect per post URL. Set up to 100000 to scrape everything available. Lower values reduce run time and cost.
## `includeReplies` (type: `boolean`):
When enabled, the actor also fetches replies nested under each comment.
## `maxRepliesPerComment` (type: `integer`):
Maximum number of replies to collect per comment. Only used when Include replies is enabled.
## `timeoutSecs` (type: `integer`):
Maximum total run time in seconds. The actor will stop gracefully when this limit is reached.
## `requestTimeoutSecs` (type: `integer`):
Timeout for each individual HTTP request to TikTok. Increase if you experience frequent timeout errors.
## `proxyConfiguration` (type: `object`):
Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect.
## Actor input object example
```json
{
"postUrls": [
"https://www.tiktok.com/@bellapoarch/video/6862153058223197445",
"https://www.tiktok.com/@charlidamelio/video/7084020840384219398"
],
"maxCommentsPerPost": 100,
"includeReplies": true,
"maxRepliesPerComment": 50,
"timeoutSecs": 300,
"requestTimeoutSecs": 30,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"postUrls": [
"https://www.tiktok.com/@bellapoarch/video/6862153058223197445"
],
"maxCommentsPerPost": 100,
"maxRepliesPerComment": 50,
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/tiktok-comments-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"postUrls": ["https://www.tiktok.com/@bellapoarch/video/6862153058223197445"],
"maxCommentsPerPost": 100,
"maxRepliesPerComment": 50,
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("kawsar/tiktok-comments-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 '{
"postUrls": [
"https://www.tiktok.com/@bellapoarch/video/6862153058223197445"
],
"maxCommentsPerPost": 100,
"maxRepliesPerComment": 50,
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call kawsar/tiktok-comments-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=kawsar/tiktok-comments-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Tiktok Comments Scraper ($0.20 Per 1K)",
"description": "TikTok comment scraper that pulls comments and replies from any public post, so researchers and marketers get usable data without copying a single comment by hand.",
"version": "0.0",
"x-build-id": "gZ033yahY0CfoiX6k"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/kawsar~tiktok-comments-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-kawsar-tiktok-comments-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/kawsar~tiktok-comments-scraper/runs": {
"post": {
"operationId": "runs-sync-kawsar-tiktok-comments-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/kawsar~tiktok-comments-scraper/run-sync": {
"post": {
"operationId": "run-sync-kawsar-tiktok-comments-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": [
"postUrls"
],
"properties": {
"postUrls": {
"title": "Post URLs",
"type": "array",
"description": "List of TikTok post URLs to scrape comments from. Supports video posts, photo posts, and short links (vm.tiktok.com).",
"items": {
"type": "string"
}
},
"maxCommentsPerPost": {
"title": "Maximum comments per post",
"minimum": 1,
"maximum": 100000,
"type": "integer",
"description": "Maximum number of comments to collect per post URL. Set up to 100000 to scrape everything available. Lower values reduce run time and cost.",
"default": 100
},
"includeReplies": {
"title": "Include replies",
"type": "boolean",
"description": "When enabled, the actor also fetches replies nested under each comment.",
"default": true
},
"maxRepliesPerComment": {
"title": "Maximum replies per comment",
"minimum": 1,
"maximum": 500,
"type": "integer",
"description": "Maximum number of replies to collect per comment. Only used when Include replies is enabled.",
"default": 50
},
"timeoutSecs": {
"title": "Actor timeout (seconds)",
"minimum": 30,
"maximum": 3600,
"type": "integer",
"description": "Maximum total run time in seconds. The actor will stop gracefully when this limit is reached.",
"default": 300
},
"requestTimeoutSecs": {
"title": "Request timeout (seconds)",
"minimum": 5,
"maximum": 120,
"type": "integer",
"description": "Timeout for each individual HTTP request to TikTok. Increase if you experience frequent timeout errors.",
"default": 30
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect."
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```