# TikTok Comments Scraper (`chronometrica/tiktok-comments-scraper`) Actor

A simple, fast TikTok comment scraper for public video and photo posts. Collect comments and replies in clean JSON or CSV with text, likes, language, timestamps, authors, and thread IDs. Built for brand monitoring, sentiment analysis, creator research, and AI. Pay only for saved results.

- **URL**: https://apify.com/chronometrica/tiktok-comments-scraper.md
- **Developed by:** [Chronometrica](https://apify.com/chronometrica) (community)
- **Categories:** Social media, Agents, Automation
- **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 comment or replies

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## TikTok Comments Scraper

### 💬 What does TikTok Comments Scraper do?

TikTok Comments Scraper is a simple, fast way to collect public TikTok comments
and replies from known video and photo posts. Paste full post URLs or numeric
post IDs and get clean, structured JSON or CSV with one analysis-ready row for
every saved comment or reply.

Use it to collect large comment datasets for brand monitoring, social
listening, creator research, thesis data collection, sentiment analysis, AI,
spreadsheets, warehouses, and automated monitoring. The structured output is
easy to analyze and includes stable post and comment IDs, comment text, public
author details, timestamps, likes, language, reply links, and visible creator
signals.

The Actor uses logged-out public TikTok data. It does not need your TikTok
account, cookies, API key, or copied browser session. It does not access private
posts or bypass access controls.

With TikTok Comments Scraper, you can:

- 📣 Study public reactions to brands, products, campaigns, and creators.
- 🔎 Find the words, questions, and topics audiences use in real comments.
- 🧠 Build datasets for sentiment analysis, topic modeling, and AI workflows.
- 🧑‍🔬 Collect structured public comments for academic and market research.
- 💬 Preserve reply threads with stable parent and reply IDs.
- 🖼️ Collect comments from both TikTok video and photo/carousel posts.
- 📊 Export results as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.
- 🔁 Run scheduled jobs through the Apify API, SDKs, webhooks, and integrations.

### 📦 What TikTok comment data can I extract?

Each default-dataset row represents one real public TikTok comment or reply.
Replies are separate rows, which keeps CSV, SQL, and per-row billing simple.

| Data group         | Main fields                                                                                       |
| ------------------ | ------------------------------------------------------------------------------------------------- |
| 🔗 Post identity   | `inputUrl`, `postUrl`, `postId`                                                                   |
| 💬 Comment         | `commentId`, `text`, `language`, `createdAt`, `likesCount`                                        |
| 🧵 Reply thread    | `parentCommentId`, `replyToCommentId`, `isReply`, `replyDepth`, `replyCount`                      |
| 👤 Public author   | `authorId`, `authorHandle`, `authorDisplayName`, `authorUrl`, `authorAvatarUrl`, `authorVerified` |
| ❤️ Creator signals | `isPinned`, `isHeartedByCreator`                                                                  |
| 📌 Collection      | `commentIndex`, `replyIndex`, `status`, `scrapedAt`                                               |

Public values that TikTok does not expose stay `null`. Missing values are not
guessed or replaced with fake zeroes.

### ✨ Why use this Actor?

- ✅ **Analysis-ready rows:** one stable shape for both comments and replies.
- 🪄 **Simple setup:** paste post URLs, choose a limit, and start the run. No
  code is required.
- 🆔 **Strict post identity:** every saved row is checked against the requested
  TikTok post ID.
- 🧹 **Run-wide deduplication:** equivalent post inputs and repeated comment IDs
  are collected once.
- 🧵 **Valid reply links:** replies carry their top-level parent ID so you can
  rebuild each thread.
- 🖼️ **Video and carousel support:** use full `/video/` and `/photo/` URLs.
- 🚦 **Honest empty results:** invalid, unsupported, unavailable, and
  no-public-comment inputs appear in the run summary instead of becoming
  charged fake rows.
- 🎛️ **Clear limits:** caps apply per post, replies have their own cap, and the
  summary explains whether the Actor reached a cap or exhausted public rows.
- 💸 **Clear billing:** one saved comment or reply is one result. Platform usage
  is included.
- 🔒 **Public-data boundary:** no user login, cookies, or private TikTok data.

In a fixed July 2026 production test, the Actor saved 1,000 unique comments
from 10 public posts in 46.9 seconds. The test produced no wrong-post rows and
no output duplicates. Live speed and available comment volume can vary by post
and over time.

### ⚙️ Can I use this Actor through an API?

Yes. Run TikTok Comments Scraper manually in Apify Console or connect it to:

- Apify API
- Python SDK
- JavaScript SDK
- Webhooks
- Scheduled runs
- Make, Zapier, n8n, Google Sheets, and other Apify integrations

This makes the Actor useful for repeatable research, dashboards, data
warehouses, AI pipelines, and monitoring jobs.

#### 🔌 API example

Start a run with the Apify API. Keep your token in an environment variable or
secret store; do not commit it to source code.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/chronometrica~tiktok-comments-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": ["https://www.tiktok.com/@zachking/video/7631200623693729038"],
    "maxCommentsPerVideo": 100,
    "includeReplies": false,
    "maxRepliesPerComment": 10
  }'
````

Use the returned run ID to check status, download dataset items, or connect a
webhook. The same input works with the Apify JavaScript and Python clients.

### 🎯 Why scrape TikTok comments?

| Use case               | How the data helps                                                    |
| ---------------------- | --------------------------------------------------------------------- |
| 📣 Brand monitoring    | Learn how audiences react to campaigns and products.                  |
| 🕵️ Competitor research | See what people praise, dislike, and ask competitors.                 |
| 🤝 Creator research    | Review audience quality and public reactions before a partnership.    |
| 🧠 Sentiment datasets  | Supply clean text for your own sentiment or topic model.              |
| 🧑‍🔬 Academic research   | Collect structured public discussion for reproducible analysis.       |
| 🔁 Ongoing monitoring  | Schedule the same known posts and compare public reactions over time. |

The Actor supplies public source data. It does not add automatic sentiment
labels or make claims about a person's intent.

### 💵 Pricing

TikTok Comments Scraper uses pay-per-result pricing. One result means one
successful public comment or reply written to the default dataset.

| Apify plan | Price per 1,000 comments or replies |
| ---------- | ----------------------------------: |
| Free       |                               $1.00 |
| Starter    |                               $0.80 |
| Scale      |                               $0.60 |
| Business   |                               $0.50 |

Platform usage is included. There is no start fee and no minimum run charge.
Invalid inputs, unsupported URLs, unavailable posts, empty public results, and
duplicate inputs do not create result rows and are not charged as results.

Use `maxCommentsPerVideo`, `includeReplies`, and `maxRepliesPerComment` to
control result volume before a run. Replies are additional result rows.

Example result charges:

| Saved rows |   Free | Business |
| ---------: | -----: | -------: |
|        100 |  $0.10 |    $0.05 |
|      1,000 |  $1.00 |    $0.50 |
|     10,000 | $10.00 |    $5.00 |

### 🚀 How do I use TikTok Comments Scraper?

1. Open **TikTok Comments Scraper** in Apify Console.
2. Paste one or more full TikTok video or photo post URLs, or numeric post IDs.
3. Choose the maximum number of top-level comments per post.
4. Turn on replies only if you need them, then set the reply cap.
5. Click **Start**.
6. Open **Output** to inspect the dataset and run summary.
7. Download the data or send it to another tool through an integration.

### ⬇️ Input

```json
{
    "startUrls": ["https://www.tiktok.com/@zachking/video/7631200623693729038"],
    "maxCommentsPerVideo": 100,
    "includeReplies": false,
    "maxRepliesPerComment": 10
}
```

#### 🔗 Supported post inputs

- Full `https://www.tiktok.com/@user/video/POST_ID` URLs
- Full `https://www.tiktok.com/@user/photo/POST_ID` URLs
- `http` or `https`
- `www`, non-`www`, and mobile TikTok hosts
- Full URLs copied without `http://` or `https://`
- Full URLs with query parameters
- Numeric TikTok post IDs

Equivalent inputs for the same post are collected once. TikTok short links
such as `vm.tiktok.com` and `vt.tiktok.com` are not supported yet. Resolve them
to a full post URL before running the Actor.

#### 🎛️ Input settings

| Setting                | What it controls                                                                                          |
| ---------------------- | --------------------------------------------------------------------------------------------------------- |
| `startUrls`            | Add 1–100 public TikTok video or photo URLs, or numeric post IDs.                                         |
| `maxCommentsPerVideo`  | Save 1–1,000 unique top-level comments for each post. Default: 100. Replies do not count toward this cap. |
| `includeReplies`       | Save public replies as separate rows. Default: off. Turning it on can increase runtime and cost.          |
| `maxRepliesPerComment` | Save 1–100 replies under each saved top-level comment when replies are enabled. Default: 10.              |

### ⬆️ Output sample

```json
{
    "inputIndex": 0,
    "inputUrl": "https://www.tiktok.com/@example/video/7631200623693729038",
    "platform": "tiktok",
    "postUrl": "https://www.tiktok.com/@example/video/7631200623693729038",
    "postId": "7631200623693729038",
    "commentId": "7600000000000000001",
    "parentCommentId": null,
    "replyToCommentId": null,
    "isReply": false,
    "replyDepth": 0,
    "commentIndex": 0,
    "replyIndex": null,
    "text": "Example public comment",
    "language": "en",
    "createdAt": "2026-07-12T18:30:00.000Z",
    "createTime": 1783881000,
    "likesCount": 42,
    "replyCount": 3,
    "authorId": "7000000000000000001",
    "authorHandle": "example_user",
    "authorDisplayName": "Example User",
    "authorUrl": "https://www.tiktok.com/@example_user",
    "authorAvatarUrl": "https://example.com/avatar.jpeg",
    "authorVerified": false,
    "isPinned": false,
    "isHeartedByCreator": false,
    "status": "ok",
    "scrapedAt": "2026-07-12T22:00:00.000Z"
}
```

Every dataset row has `status: "ok"`. Inputs that do not produce a real public
comment row are explained in the `OUTPUT` run summary instead.

#### 🧵 Comment and reply fields

- `commentId` is the stable row identity used for deduplication.
- `parentCommentId` is `null` for a top-level comment. For a reply, it points to
  the saved top-level parent row.
- `replyToCommentId` identifies the directly replied-to comment when TikTok
  exposes it.
- `commentIndex` and `replyIndex` are zero-based saved positions, not TikTok
  relevance scores.
- `replyCount` is the public reply total for a top-level comment. It is `null`
  on reply rows because it is not applicable there.
- `createdAt` and `createTime` describe when TikTok says the comment was
  created. `scrapedAt` describes when this Actor collected the row.
- `isPinned`, `isHeartedByCreator`, and `authorVerified` stay `null` if TikTok
  does not expose the public flag. They are not guessed as `false`.

### 🧾 Run summary

The `OUTPUT` record helps you check the whole run. It includes:

- inputs received and unique posts planned;
- duplicate post inputs skipped;
- posts attempted and posts with rows;
- top-level comments and replies written;
- candidates seen and duplicate comments skipped;
- public outcome and stop-reason counts;
- safe details for inputs that did not produce rows;
- request, retry, and pagination totals.

| Input outcome            | Meaning                                                            |            Result charge |
| ------------------------ | ------------------------------------------------------------------ | -----------------------: |
| `ok`                     | One or more public comment rows were saved.                        | One charge per saved row |
| `no_public_comments`     | The public post resolved, but TikTok returned no public comments.  |                     None |
| `deleted_or_unavailable` | The post could not be validated as publicly available.             |                     None |
| `private`                | The post was not available to logged-out public viewers.           |                     None |
| `blocked_or_challenged`  | TikTok did not expose public comments for that request.            |                     None |
| `invalid_input`          | The input was not a TikTok post URL or numeric post ID.            |                     None |
| `unsupported_url`        | The URL was TikTok-related but outside the supported post formats. |                     None |
| `failed` or `partial`    | A temporary request stopped all or part of the post collection.    |          Saved rows only |

If a post produces no rows, check `failedInputDetails` in `OUTPUT`. It keeps the
input, post ID when available, outcome, plain-language reason, and whether a
retry may help. The Actor does not hide an empty result behind a successful
dataset row.

### 🔒 Public-data boundary

TikTok Comments Scraper uses logged-out public TikTok surfaces only.

It does not:

- request your TikTok username or password;
- use your account, cookies, or copied browser session;
- collect private or followers-only posts;
- solve access challenges or bypass login controls;
- discover posts from profiles, keywords, or hashtags;
- download TikTok videos or photos;
- promise every comment shown by TikTok's displayed total.

### ⚠️ Limits and interpretation

- TikTok decides which comments and replies are visible to logged-out public
  viewers.
- Deleted, hidden, filtered, region-limited, or moderated comments may not be
  available.
- A displayed TikTok comment total can be higher than the rows available from
  the public continuation source.
- `maxCommentsPerVideo` and `maxRepliesPerComment` are hard saved-row caps, not
  promises that every post has that much public inventory.
- Comment order follows the public source order. It is not a custom relevance,
  sentiment, or most-liked ranking.
- Likes, replies, author details, pins, hearts, and public availability can
  change between runs.
- Short TikTok share links are not supported yet.

### ❓ FAQ

#### Does this Actor need a TikTok API key or login?

No. It uses logged-out public TikTok data and does not need your account,
cookies, or API key.

#### Does it support TikTok photo and carousel posts?

Yes. Paste the full `/photo/POST_ID` URL. Comments and replies use the same
dataset shape as video-post comments.

#### Are replies charged?

Yes. Each successfully saved reply is its own dataset row and result. Leave
`includeReplies` off when you only need top-level comments.

#### Why did I receive fewer comments than the displayed TikTok total?

TikTok's displayed total and its logged-out public continuation inventory can
differ. The run summary reports whether the Actor reached your cap or exhausted
the available public source.

#### How does deduplication work?

Equivalent URLs and IDs for the same post are collected once per run. Saved
rows are deduplicated by TikTok's stable comment ID.

#### Can it collect private posts or comments that require login?

No. Private, account-only, and otherwise unavailable data is outside the
Actor's public-data boundary.

### 🏆 Best practices

- 🎯 Start with 50–100 comments while testing a new workflow.
- 💬 Turn on replies only when conversation threads matter to your analysis.
- 🔗 Use full video or photo URLs instead of TikTok short links.
- 🧾 Check `OUTPUT` before treating a small dataset as a failure.
- 🆔 Join and deduplicate downstream work with `postId` and `commentId`.
- 🔁 Schedule repeated runs when you need to observe public comment changes
  over time.

### 🛟 Support

For help, include the Apify run ID, one example input URL or post ID, what you
expected, and the status shown in `OUTPUT`. Do not send TikTok passwords,
cookies, session data, or private links.

### ⚖️ Responsible use

This Actor collects data that TikTok exposes to logged-out public viewers at
run time. You are responsible for using the data lawfully and for following
applicable privacy, data-protection, research, and platform rules. Avoid using
public comments to harass people, infer sensitive traits, or make automated
high-impact decisions about individuals.

### 🔗 Related social media scrapers

Combine this Actor with our other social media scrapers for discovery,
performance tracking, comment research, and transcript collection.

#### TikTok

- [TikTok Search Scraper](https://apify.com/chronometrica/tiktok-search-scraper)
  — find public TikTok videos, creators, and metrics by keyword.
- [TikTok Metrics Scraper](https://apify.com/chronometrica/tiktok-metrics-scraper)
  — collect public video, profile, engagement, hashtag, and music data.
- [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper)
  — extract public caption text and timestamped segments from TikTok videos.

#### Facebook

- [Facebook Metrics Scraper](https://apify.com/chronometrica/facebook-metrics-scraper)
  — collect public post, Reel, video, and profile/page metrics.
- [Facebook Comments Scraper](https://apify.com/chronometrica/facebook-comments-scraper)
  — collect public comments, replies, authors, dates, and reactions from known
  Facebook content.

#### Instagram

- [Instagram Metrics Scraper](https://apify.com/chronometrica/instagram-metrics-scraper)
  — collect public post, Reel, carousel, profile, and collaboration metrics.
- [Instagram Comments Scraper](https://apify.com/chronometrica/instagram-comments-scraper)
  — collect public comments, authors, dates, likes, and reply counts from posts
  and Reels.

#### YouTube

- [YouTube Search Scraper](https://apify.com/chronometrica/youtube-search-scraper)
  — find public videos, Shorts, channels, and metrics by keyword.
- [YouTube Metrics Scraper](https://apify.com/chronometrica/youtube-metrics-scraper)
  — collect public video, Short, channel, and engagement metrics.
- [YouTube Comments Scraper](https://apify.com/chronometrica/youtube-comments-scraper)
  — collect public comments, replies, authors, likes, pins, and creator hearts.
- [YouTube Transcript Scraper](https://apify.com/chronometrica/youtube-transcript-scraper)
  — extract public captions as clean text, timestamps, SRT, VTT, or LLM-ready
  output.

# Actor input Schema

## `startUrls` (type: `array`):

Add 1–100 public TikTok video or photo/carousel URLs, or numeric post IDs. Equivalent inputs are collected once. Short links are not supported yet.

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

Maximum top-level comments saved for each post. Range: 1–1,000. A smaller value lowers runtime and cost.

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

Also save public replies as separate billable rows. Replies increase runtime and cost.

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

Maximum replies saved for each top-level comment when replies are enabled. Range: 1–100. This setting is ignored when replies are off.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.tiktok.com/@zachking/video/7631200623693729038"
  ],
  "maxCommentsPerVideo": 100,
  "includeReplies": false,
  "maxRepliesPerComment": 10
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "startUrls": [
        "https://www.tiktok.com/@zachking/video/7631200623693729038"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("chronometrica/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 = { "startUrls": ["https://www.tiktok.com/@zachking/video/7631200623693729038"] }

# Run the Actor and wait for it to finish
run = client.actor("chronometrica/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 '{
  "startUrls": [
    "https://www.tiktok.com/@zachking/video/7631200623693729038"
  ]
}' |
apify call chronometrica/tiktok-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Comments Scraper",
        "description": "A simple, fast TikTok comment scraper for public video and photo posts. Collect comments and replies in clean JSON or CSV with text, likes, language, timestamps, authors, and thread IDs. Built for brand monitoring, sentiment analysis, creator research, and AI. Pay only for saved results.",
        "version": "0.1",
        "x-build-id": "OGj1Dmzexbwi7GUDf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~tiktok-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-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/chronometrica~tiktok-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-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/chronometrica~tiktok-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "TikTok post URLs or IDs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add 1–100 public TikTok video or photo/carousel URLs, or numeric post IDs. Equivalent inputs are collected once. Short links are not supported yet.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCommentsPerVideo": {
                        "title": "Top-level comments per post",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum top-level comments saved for each post. Range: 1–1,000. A smaller value lowers runtime and cost.",
                        "default": 100
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Also save public replies as separate billable rows. Replies increase runtime and cost.",
                        "default": false
                    },
                    "maxRepliesPerComment": {
                        "title": "Replies per top-level comment",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum replies saved for each top-level comment when replies are enabled. Range: 1–100. This setting is ignored when replies are off.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
