# TikTok Comments Scraper – No Login (`datascraperes/tiktok-comments-scraper`) Actor

Collect public TikTok comments and replies from video URLs. Export comment text, likes, timestamps and public author details in structured results. Set limits for comments, replies and total results, and pay only $0.50 per 1,000 saved comments or replies. No login is required.

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

## Pricing

$0.50 / 1,000 comments

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Comments Scraper – No Login

Collect public comments from one or more TikTok videos and receive one clear Dataset item per saved comment. Enable reply collection when you also need the public replies attached to those comments.

Use the Actor for audience research, comment analysis, content research, engagement reporting, moderation review, competitor research and other workflows that need structured TikTok comment data.

No TikTok account, password, official TikTok API key, browser session or cookies are required. The Actor only collects information that TikTok makes publicly available at the time of the run.

> **Important:** This is an independent, unofficial third-party Actor. It is not affiliated with, sponsored by, endorsed by or approved by TikTok. You are responsible for using the results lawfully and respecting TikTok's terms and the privacy rights that apply to the source data.

### At a glance

- Collect comments from one or many public TikTok video URLs.
- Use a numeric TikTok video ID instead of a URL when that is more convenient.
- Optionally collect public replies and keep their parent comment relationship.
- Receive one Dataset row per successfully saved top-level comment or reply.
- Keep duplicate videos and duplicate comments from creating duplicate results.
- Set separate limits per video, per reply thread and for the complete run.
- Save compact diagnostic rows when a video has no available comments or cannot be completed.
- Export the Dataset from Apify as JSON, CSV, Excel or another available format.
- Pay only for successfully saved comment and reply results.

### What data is extracted?

Each successful Dataset item represents one public TikTok comment or reply and can include:

| Field | Description |
| --- | --- |
| `videoId` | Public TikTok identifier of the video containing the comment. |
| `videoUrl` | Canonical TikTok video URL associated with the result. |
| `sourceInput` | The URL or numeric video ID supplied in the input. |
| `commentId` | Stable public identifier of the comment. |
| `parentCommentId` | Identifier of the top-level comment for a reply; `null` for a top-level comment. |
| `isReply` | `true` for a reply and `false` for a top-level comment. |
| `text` | Public comment text when TikTok makes it available. |
| `createdAt` | Comment creation time in ISO date-time format when available. |
| `createTime` | Original Unix timestamp when available. |
| `likeCount` | Public like count for the comment when available. |
| `replyCount` | Public reply count associated with the comment when available. |
| `isPinned` | Whether the comment is publicly marked as pinned by its author. |
| `commentLanguage` | Public language value supplied for the comment when available. |
| `threadHasMore` | Whether TikTok indicates that more replies may be available for the thread. |
| `author` | Public author ID, username, nickname and verification status when available. |
| `retrievedAt` | Time at which the result was collected. |

Public counters, text and author fields are snapshots. They can change after the run, and TikTok may leave individual fields empty when they are not publicly available for a particular comment.

The Actor returns comment metadata and text. It does not download videos or images, access private comments, publish comments, like content or modify TikTok accounts.

### How to use the Actor in Apify

1. Open the Actor and go to the **Input** tab.
2. Add one or more direct TikTok video URLs or numeric video IDs in **TikTok video URLs or IDs**.
3. Choose how many top-level comments you want per video.
4. Enable **Include replies** if you also want public replies.
5. Set the total result limit to keep the Dataset size and cost predictable.
6. Click **Start**.
7. Open the **Dataset** tab to review, filter or export the results.
8. When a video has no results or is incomplete, open the diagnostic row and the `SUMMARY` record for the reason.

For a first run, use one public video and a small limit such as `5` or `20`.

#### Quick start input

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@zachking/video/7631200623693729038"
  ],
  "maxCommentsPerVideo": 20,
  "maxTotalComments": 20,
  "includeReplies": false
}
```

### Input options

#### `videoUrls` — required

List of direct public TikTok video URLs or numeric video IDs. The input accepts up to 1,000 unique videos per run.

Accepted examples:

```json
[
  "https://www.tiktok.com/@creatorname/video/1234567890123456789",
  "https://www.tiktok.com/video/1234567890123456789",
  "1234567890123456789"
]
```

The Actor also accepts the `m.tiktok.com` version of a direct video URL. Video IDs must contain only digits. Direct URLs may include a query string or fragment.

Use a direct video URL containing `/video/<numeric-id>` or provide the numeric ID itself. Profile URLs, hashtag pages, sound pages, shortened sharing links and other TikTok pages are not valid video inputs. Private, deleted or unavailable videos cannot be collected.

Repeated URLs that refer to the same video ID are processed once. The Dataset keeps the first accepted input for that video.

#### `maxCommentsPerVideo`

Maximum number of top-level comments to save for each video.

- Default: `20`
- Minimum: `1`
- Maximum: `10,000`

This limit applies to top-level comments. Replies have their own per-thread limit, and both top-level comments and replies also count toward `maxTotalComments`. TikTok may expose fewer comments than the number shown in its app or on the video page.

#### `includeReplies`

Whether to collect public replies for the top-level comments that are saved.

- Default: `false`
- Set to `true` when threaded discussion is needed.

Replies are saved as separate Dataset rows. They use the same result price as top-level comments and count toward `maxTotalComments`.

#### `maxRepliesPerComment`

Maximum number of public replies to save for each collected top-level comment when replies are enabled.

- Default: `10`
- Minimum: `0`
- Maximum: `100`
- Set to `0` to disable reply collection even when `includeReplies` is `true`.

This limit controls each individual reply thread, not the complete run.

#### `maxTotalComments`

Maximum number of saved results across the complete run. The count includes both top-level comments and replies from all videos.

- Default: `100`
- Minimum: `1`
- Maximum: `100,000`

This is the most important option for controlling Dataset size and the maximum possible result charge. For example, `maxTotalComments: 1,000` allows at most 1,000 saved rows, regardless of the number of videos or comments available.

#### `maxPagesPerVideo`

Maximum number of comment pages requested for each video.

- Default: `50`
- Minimum: `1`
- Maximum: `1,000`

The default is suitable for normal runs. Increase it only when a large comment section reaches `MAX_PAGES` before the desired per-video comment limit is reached.

#### `maxReplyPagesPerComment`

Maximum number of pages requested for each reply thread when replies are enabled.

- Default: `10`
- Minimum: `1`
- Maximum: `500`

This is a safety limit for unusually large reply threads. It does not increase `maxRepliesPerComment` by itself.

#### `saveDiagnostics`

Whether to save a compact diagnostic Dataset row for a video with no saved comments or a collection error.

- Default: `true`
- Diagnostic rows are not charged as comment or reply results.
- Set to `false` when you want a Dataset containing only successful comment and reply rows.

### Examples for common goals

#### Collect a small sample from one video

Use this to verify the video and inspect the result format before a larger run:

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@examplecreator/video/1234567890123456789"
  ],
  "maxCommentsPerVideo": 10,
  "maxTotalComments": 10,
  "includeReplies": false
}
```

#### Collect comments and a controlled number of replies

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@examplecreator/video/1234567890123456789"
  ],
  "maxCommentsPerVideo": 50,
  "includeReplies": true,
  "maxRepliesPerComment": 5,
  "maxTotalComments": 200
}
```

The total cap includes the 50 possible top-level comments and every reply saved from those threads. The run can therefore stop before all selected top-level comments or replies are collected.

#### Process several videos with a predictable maximum

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@creatorone/video/1234567890123456789",
    "https://www.tiktok.com/@creatortwo/video/9876543210987654321",
    "9876543210987654321"
  ],
  "maxCommentsPerVideo": 100,
  "maxTotalComments": 250,
  "includeReplies": false,
  "saveDiagnostics": true
}
```

The repeated second video ID is processed only once. The complete run cannot save more than 250 billable comment or reply rows.

#### Keep only successful result rows

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@examplecreator/video/1234567890123456789"
  ],
  "maxCommentsPerVideo": 100,
  "maxTotalComments": 100,
  "saveDiagnostics": false
}
```

With diagnostics disabled, a video that has no available comments does not add a placeholder row to the Dataset.

### Understanding the results

#### Successful comment or reply record

Successful rows have `success: true`, `status: "ok"` and `recordType: "comment"`:

```json
{
  "success": true,
  "status": "ok",
  "recordType": "comment",
  "retrievedAt": "2026-08-18T10:20:30Z",
  "sourceInput": "https://www.tiktok.com/@examplecreator/video/1234567890123456789",
  "videoId": "1234567890123456789",
  "videoUrl": "https://www.tiktok.com/@examplecreator/video/1234567890123456789",
  "commentId": "1234567890123456790",
  "parentCommentId": null,
  "isReply": false,
  "text": "Public comment text",
  "createTime": 1755512430,
  "createdAt": "2025-08-18T10:20:30Z",
  "likeCount": 42,
  "replyCount": 3,
  "isPinned": false,
  "commentLanguage": "en",
  "threadHasMore": true,
  "author": {
    "id": "7255155351183246362",
    "username": "public_username",
    "nickname": "Public name",
    "verified": false
  }
}
```

For a reply, `isReply` is `true` and `parentCommentId` contains the ID of the top-level comment to which it belongs. A reply is one additional saved result and one additional chargeable row.

The `author` object contains only public profile values that TikTok exposes. Any unavailable value can be `null`. A `null` counter or date means that TikTok did not provide that field for the result.

#### Diagnostic records

When `saveDiagnostics` is enabled, the Actor can add one compact `recordType: "video_diagnostic"` row for a video with no saved comments or an incomplete collection. A diagnostic row is not a comment and is not charged:

```json
{
  "success": false,
  "status": "empty",
  "recordType": "video_diagnostic",
  "retrievedAt": "2026-08-18T10:20:30Z",
  "sourceInput": "https://www.tiktok.com/@examplecreator/video/1234567890123456789",
  "videoId": "1234567890123456789",
  "videoUrl": "https://www.tiktok.com/@examplecreator/video/1234567890123456789",
  "errorCode": null,
  "errorMessage": null,
  "pages": 1,
  "commentsReceived": 0,
  "commentsSaved": 0,
  "repliesSaved": 0,
  "duplicatesSkipped": 0,
  "replyPages": 0,
  "totalAvailable": 0,
  "stopReason": "NO_COMMENTS"
}
```

Diagnostic rows are useful for distinguishing an empty video from a video that reached a configured limit or encountered a temporary access problem.

#### `SUMMARY` record

After each run, open the **Key-value store** and the `SUMMARY` record for an overview of the collection. It includes information such as:

- Number of videos requested and processed.
- Total saved comments and replies.
- Top-level comments saved separately from replies.
- Estimated result charge and the maximum possible charge from `maxTotalComments`.
- Per-video counts, pages, duplicates and stop reasons.
- Error codes when a video could not be completed.

Useful stop reasons include:

| Stop reason | Meaning |
| --- | --- |
| `COMPLETE` | The public comment pages available during the run were exhausted. |
| `MAX_COMMENTS_PER_VIDEO` | The per-video top-level comment limit was reached. |
| `MAX_TOTAL_COMMENTS` | The run-wide comment and reply limit was reached. |
| `MAX_PAGES` | The per-video page limit was reached before collection finished. |
| `MAX_REPLY_PAGES` | The reply-thread page limit was reached. |
| `NO_COMMENTS` | No public comments were available for the video during the run. |
| `CHARGE_LIMIT` | Apify stopped the run before another chargeable result could be saved. |
| An error code | The video could not be completed; inspect the diagnostic row and try again later when appropriate. |

The selected limits are maximums, not guarantees. `SUMMARY` and the Dataset show the number that was actually collected.

### Pricing

The Actor charges **$0.001 per successfully saved comment or reply** — equivalent to **$1 per 1,000 saved results**.

- A top-level comment uses one result charge.
- A saved reply uses one result charge.
- Duplicate comments, empty videos and diagnostic rows are not charged as comment results.
- There is no separate customer charge for starting a run.
- `maxTotalComments` is a hard upper bound for the number of possible chargeable results.

For example:

- 100 saved comments or replies cost **$0.10**.
- 1,000 saved comments or replies cost **$1.00**.
- A run with no saved comments has no comment-result charge.

The final amount is based on the rows actually saved, not on the number of comments displayed by TikTok or the number requested in the input.

### Limitations and important expectations

- Only public TikTok videos and public comments that are available during the run can be collected.
- Private, deleted, age-restricted, region-restricted, unavailable or temporarily inaccessible videos may return no results or a diagnostic row.
- A limit such as `maxCommentsPerVideo` or `maxTotalComments` is an upper bound, not a promise that TikTok will return that many comments.
- TikTok may return fewer comments than its visible comment counter suggests.
- TikTok can change comment ordering, pagination, text, counters and available author fields between runs.
- Replies are collected only for top-level comments that the Actor successfully saves and only while the configured total limit remains available.
- The Actor does not download video files, images or media attachments.
- The Actor does not collect private account information, passwords or login credentials.
- Public usernames, nicknames and comment text can contain personal data. Store, analyze and share the Dataset according to your legal obligations and the purpose for which you collected it.

### Troubleshooting

#### The run returns no comments

Check that:

1. The input is a direct TikTok video URL containing `/video/<numeric-id>` or a numeric video ID.
2. The video is public and currently available.
3. `maxCommentsPerVideo` and `maxTotalComments` are greater than zero.
4. The diagnostic row and `SUMMARY` record do not report `NO_COMMENTS`, an access problem or another stop reason.

Shortened share links, profile URLs, hashtag URLs and sound URLs must be replaced with the direct video URL.

#### The run returns fewer comments than expected

Review `stopReason`, `totalAvailable`, `commentsReceived` and `commentsSaved` in the diagnostic row or `SUMMARY`. The result may be limited by the selected per-video limit, the run-wide limit, the page limit, duplicate IDs or the comments that TikTok made publicly available at that time.

#### Replies are missing

Confirm that `includeReplies` is `true` and that `maxRepliesPerComment` is greater than `0`. Also check that `maxTotalComments` leaves room for replies after top-level comments have been saved. Some comments have no public replies, and TikTok may not expose every reply in a thread.

#### The run stops at `MAX_PAGES` or `MAX_REPLY_PAGES`

Increase the corresponding page limit only when you need to inspect a larger comment section or reply thread. Keep `maxCommentsPerVideo`, `maxRepliesPerComment` and `maxTotalComments` finite when you want predictable result volume and cost.

#### A video has an error diagnostic

Inspect `errorCode`, `errorMessage` and `stopReason`, verify that the video is public, and try the same input again later if the problem appears temporary. Do not include passwords, tokens or other private credentials when reporting the issue.

### Frequently asked questions

#### Do I need a TikTok account or login?

No. The Actor is designed for public TikTok videos and does not ask for TikTok credentials.

#### Do I need an official TikTok API key?

No. There is no API key field in the input.

#### Can I process several videos in one run?

Yes. Add multiple direct video URLs or numeric IDs to `videoUrls`. The Actor removes repeated video IDs and applies `maxTotalComments` across the complete run.

#### Can I use a numeric video ID instead of a URL?

Yes. Add the numeric ID as a string, for example `"1234567890123456789"`. The output includes the normalized TikTok video URL.

#### Can I collect all comments from a video?

Set a high `maxCommentsPerVideo` value and a suitable `maxPagesPerVideo` value, but treat the result as all public comments available to the Actor during that run. TikTok's visible counter is not a guarantee of complete historical coverage.

#### Can I collect replies?

Yes. Set `includeReplies` to `true`, choose `maxRepliesPerComment`, and leave enough room in `maxTotalComments`. Replies are returned as separate rows linked through `parentCommentId`.

#### Are likes and reply counts exact and permanent?

No. They are public snapshots collected at a particular time and can change between runs. TikTok may also omit a counter for some comments.

#### Are videos, images or media downloaded?

No. The Actor returns structured comment data and links to the associated video, but it does not download media files.

#### How do I export the results?

Open the Dataset associated with the run and use Apify's export options to download JSON, CSV, Excel or another available format.

#### Is this an official TikTok product?

No. This is an independent Actor that collects public information from TikTok. It is not affiliated with or endorsed by TikTok.

#### Is collecting TikTok comments legal?

The Actor is limited to public information, but you are responsible for deciding whether your use complies with applicable law, privacy obligations, TikTok's terms and any contractual restrictions. Do not collect or process personal data without an appropriate lawful basis.

### Support

When reporting a problem, include the Apify run ID, the input video URL or ID, the relevant `SUMMARY` stop reason and a small example of the affected result. Do not include passwords, tokens or private credentials.

# Actor input Schema

## `videoUrls` (type: `array`):

Use a public TikTok video URL or numeric video ID. Short share URLs, profile URLs and private videos are not accepted.

## `maxCommentsPerVideo` (type: `integer`):

Maximum number of top-level comments to collect from each video. The endpoint may return fewer comments than requested.

## `includeReplies` (type: `boolean`):

Fetch public replies for each collected top-level comment. Replies use the same per-comment charge and are bounded by the reply limit.

## `maxRepliesPerComment` (type: `integer`):

Maximum public replies to fetch for each top-level comment when replies are enabled. Set 0 to disable reply requests.

## `maxTotalComments` (type: `integer`):

Hard run-wide limit across top-level comments and replies. Each saved row uses one comment PPE event and this limit protects cost and runtime for large batches.

## `maxPagesPerVideo` (type: `integer`):

Safety guard against endpoint or cursor drift. Each page normally contains up to 20 comments, but TikTok may return fewer.

## `maxReplyPagesPerComment` (type: `integer`):

Safety guard for reply pagination. It applies only when replies are enabled.

## `saveDiagnostics` (type: `boolean`):

Save a compact non-chargeable diagnostic row when a video has no comments or a collection stops with an error.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@zachking/video/7631200623693729038"
  ],
  "maxCommentsPerVideo": 20,
  "includeReplies": false,
  "maxRepliesPerComment": 10,
  "maxTotalComments": 100,
  "maxPagesPerVideo": 50,
  "maxReplyPagesPerComment": 10,
  "saveDiagnostics": true
}
```

# Actor output Schema

## `comments` (type: `string`):

Dataset records emitted by this Actor.

## `summary` (type: `string`):

Per-video coverage, stop reasons, transport, and billing metadata.

# 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 = {
    "videoUrls": [
        "https://www.tiktok.com/@zachking/video/7631200623693729038"
    ],
    "maxCommentsPerVideo": 20,
    "includeReplies": false,
    "maxRepliesPerComment": 10,
    "maxTotalComments": 100,
    "maxPagesPerVideo": 50,
    "maxReplyPagesPerComment": 10,
    "saveDiagnostics": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascraperes/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "videoUrls": ["https://www.tiktok.com/@zachking/video/7631200623693729038"],
    "maxCommentsPerVideo": 20,
    "includeReplies": False,
    "maxRepliesPerComment": 10,
    "maxTotalComments": 100,
    "maxPagesPerVideo": 50,
    "maxReplyPagesPerComment": 10,
    "saveDiagnostics": True,
}

# Run the Actor and wait for it to finish
run = client.actor("datascraperes/tiktok-comments-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "videoUrls": [
    "https://www.tiktok.com/@zachking/video/7631200623693729038"
  ],
  "maxCommentsPerVideo": 20,
  "includeReplies": false,
  "maxRepliesPerComment": 10,
  "maxTotalComments": 100,
  "maxPagesPerVideo": 50,
  "maxReplyPagesPerComment": 10,
  "saveDiagnostics": true
}' |
apify call datascraperes/tiktok-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datascraperes/tiktok-comments-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/y3QvCb1acGNUXocQ2/builds/7OcWgBI3LTOnObPss/openapi.json