# Tiktok Comments Scraper (`scraperx/tiktok-comments-scraper`) Actor

💬 TikTok Comments Scraper pulls comments, usernames, timestamps, likes, and reply threads from any TikTok post. ⚡ Fast & accurate, with CSV/JSON exports and API-ready output. 📊 Ideal for social listening, UGC mining, competitor analysis & influencer marketing.

- **URL**: https://apify.com/scraperx/tiktok-comments-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

Tiktok Comments Scraper is a production-ready TikTok comment scraper tool that lets you scrape TikTok video comments at scale — complete with timestamps, commenter details, like counts, mentions, and optional replies. It solves the pain of collecting clean, structured TikTok comments JSON from public posts and can also discover videos from profiles (videos or reposts) before scraping. Built for marketers, developers, analysts, and researchers, this TikTok comments extractor enables bulk extract TikTok comments workflows and downstream analysis with CSV/JSON exports. 🚀

### What is Tiktok Comments Scraper?

Tiktok Comments Scraper is a scalable TikTok comment crawler that extracts structured comments (and optional replies) from TikTok videos. It addresses the challenge of gathering clean, timestamped comment data with user info and mentions — a reliable TikTok comments API alternative that outputs JSON. For marketers, developers, data analysts, and researchers, it powers automated pipelines to download TikTok comments, perform TikTok comment sentiment analysis, and export TikTok comments to CSV for reporting at scale.

### What data / output can you get?

Below are the exact fields the actor pushes to the Apify Dataset for each comment (replies share the same shape, without a nested replies array):

| Data field | Description | Example value |
| --- | --- | --- |
| videoWebUrl | Canonical web URL of the TikTok video | https://www.tiktok.com/@mrbeast/video/7578547467189374239 |
| submittedVideoUrl | Submitted/canonical URL for traceability (same as videoWebUrl) | https://www.tiktok.com/@mrbeast/video/7578547467189374239 |
| input | The original input URL used for scraping | https://www.tiktok.com/@mrbeast/video/7578547467189374239 |
| cid | Comment ID | 7578605549794034443 |
| createTime | Comment creation time (unix seconds) | 1732995615 |
| createTimeISO | Comment creation time (ISO) | 2025-11-30T19:40:15.000Z |
| text | Comment text content | mr beast are you ok ? |
| diggCount | Number of likes on the comment | 7633 |
| likedByAuthor | Whether the video author liked the comment | false |
| pinnedByAuthor | Whether the video author pinned the comment | false |
| repliesToId | Parent comment ID (null for top-level comments) | null |
| replyCommentTotal | Reply count reported by TikTok | 100 |
| uid | Commenter numeric user ID | 7516601022924489733 |
| uniqueId | Commenter username | amin.hrizi4 |
| avatarThumbnail | URL to commenter’s avatar thumbnail | https://p16-sign-va.tiktokcdn.com/... |
| mentions | Flat list of @mentions parsed from text | [] |
| detailedMentions | Structured mention ranges and IDs | [] |
| replies | Array of reply objects (same shape as comments, without nested replies) | [] |

Notes:
- Replies are included as an array inside their parent comment, with the same fields (excluding the nested replies array).
- Results are pushed as individual records to the Apify Dataset and also saved as a full JSON array to the key‑value store under output.json. From the Dataset, you can export TikTok comments to CSV or JSON for integration and reporting.

### Key features

- 🚀 Bulk video inputs & profile discovery  
  Feed multiple postURLs directly or discover videos from profiles using profileScrapeSections ("videos" or "reposts"), profileSorting ("latest", "popular", "oldest"), and date filters.

- 🧵 Replies with limits  
  Capture top-level comments and optionally fetch replies per comment with maxRepliesPerComment for efficient, targeted extraction.

- ⏱️ Timestamps & mentions extraction  
  Download TikTok comments with createTime and createTimeISO, and parse @mentions from both text and text_extra for richer analytics.

- 🧠 Smart proxy fallback (no API required)  
  Built-in Proxy Manager starts with no proxy, falls back to datacenter, then residential with up to 3 retries — a robust TikTok comments scraper no API approach.

- ⚖️ High concurrency & resilient requests  
  Async pipeline with retries, cursor pagination, and semaphores delivers reliable, large-scale TikTok comments dataset creation.

- 📦 Structured JSON output  
  Clean, machine-readable objects with commenter info, engagement metrics, mentions, and flattened replies — ideal for analytics pipelines.

- 🧰 Developer-friendly, Python-based  
  Implemented with the Apify SDK. Access results via the Dataset API for seamless TikTok comment scraper Python workflows.

### How to use Tiktok Comments Scraper - step by step

1. Sign in to Apify Console and open the Tiktok Comments Scraper actor.
2. Choose your source:  
   - To scrape TikTok comments from specific videos, paste one or more full video URLs into postURLs.  
   - To discover videos from profiles, add usernames (without @) to profiles.
3. Configure profile discovery (if using profiles):  
   - resultsPerPage: how many videos per profile to collect.  
   - profileScrapeSections: select "videos" and/or "reposts".  
   - profileSorting: choose "latest", "popular", or "oldest".  
   - Optional date filters: oldestPostDateUnified and newestPostDate (absolute YYYY-MM-DD or relative like “5 days”, “2 weeks”).  
   - excludePinnedPosts to skip pinned content.
4. Set scraping depth:  
   - commentsPerPost: maximum number of comments to extract per video.  
   - maxRepliesPerComment: number of replies to fetch per comment (0 to skip replies).
5. Configure proxyConfiguration if needed:  
   - The run starts with no proxy. On blocks, it falls back to datacenter, then residential with up to 3 retries, and stays “sticky” on residential thereafter.
6. Run the actor and monitor logs:  
   - Look for “PROXY EVENT” messages and per-video progress (e.g., Saved X comments).
7. Access results:  
   - View structured records in the Dataset. A full JSON array is also saved to the key‑value store as output.json.
8. Export and integrate:  
   - Export from the Dataset to JSON or CSV for BI tools and workflow automation.

Pro Tip: Trigger runs via the Apify API and pipe the Dataset to your warehouse or automation stack (n8n, Make, Zapier) to build a repeatable TikTok comments export toolchain.

### Use cases

| Use case | Description |
| --- | --- |
| Social media analysis | Aggregate and analyze engagement across videos; track themes with mentions and timestamps for TikTok comment analysis. |
| Content research | Understand audience reactions to creators and campaigns by extracting TikTok video comments with optional replies. |
| Market research | Measure responses to branded content without relying on a TikTok comments API; build a TikTok comments dataset. |
| Trend tracking | Monitor topics over time via profile-based discovery (videos/reposts) and scrape TikTok comments consistently. |
| Community monitoring | Continuously collect feedback and detect issues by crawling comments for selected profiles or posts. |
| Data enrichment (API) | Feed structured comment objects into analytics pipelines through the Apify Dataset API for modeling. |
| Academic research | Build datasets of public discourse with timestamps and user metadata for quantitative studies. |

### Why choose Tiktok Comments Scraper?

This tool focuses on reliability, structure, and scale — a dependable TikTok comment scraper tool for production workflows.

- ✅ Accurate, structured records: Text, timestamps, counts, mentions, and commenter identifiers for analysis-ready datasets.
- 🌐 Profile-based discovery: Discover videos via “videos”/“reposts” with sorting and date filters to scrape TikTok comments at scale.
- 📈 Built for scale: Concurrency, retries, and pagination for efficient bulk extract TikTok comments operations.
- 🧩 Developer access: JSON records in the Apify Dataset and a full output.json for easy API consumption and Python integration.
- 🛡️ Resilient proxy strategy: Automatic fallback from no proxy → datacenter → residential (with retries) when blocked.
- 🧱 Cloud-native stability: More reliable than browser extensions and unstable scripts; designed for long-running jobs with clear logging.

In short, it’s a robust TikTok comments extractor that outperforms one-off scripts — ideal for teams that need consistent TikTok comments JSON exports.

### Is it legal / ethical to use Tiktok Comments Scraper?

Yes — when done responsibly. This actor collects data from publicly available TikTok pages and does not access private or password‑protected content. You are responsible for:
- Scraping only public data and respecting platform terms.
- Ensuring compliance with applicable regulations (e.g., GDPR, CCPA).
- Using the data ethically (e.g., no spam or misuse of personal information).

If you operate in a regulated industry or jurisdiction, consult your legal team to confirm compliance.

### Input parameters & output format

#### Example input JSON

```json
{
  "postURLs": [
    "https://www.tiktok.com/@mrbeast/video/7578547467189374239"
  ],
  "commentsPerPost": 100,
  "maxRepliesPerComment": 3,
  "profiles": ["mrbeast"],
  "resultsPerPage": 10,
  "profileScrapeSections": ["videos"],
  "profileSorting": "latest",
  "oldestPostDateUnified": "2 weeks",
  "newestPostDate": "2025-12-01",
  "excludePinnedPosts": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| postURLs | array of strings | No | — | TikTok video URLs to extract comments from. If provided, these take priority over profiles. |
| commentsPerPost | integer | No | 100 | The number of comments extracted from every result. Due to TikTok API limitations, the actual number of scraped comments may differ, especially for posts with thousands of comments. |
| maxRepliesPerComment | integer | No | 3 | The maximum number of replies you want from a single comment. Note: Successful extraction of all desired replies is currently not guaranteed. |
| profiles | array of strings | No | — | TikTok usernames (without @) to scrape videos from (profile-based discovery). |
| resultsPerPage | integer | No | 10 | Number of videos you want to scrape per profile (min 1, max 1,000,000). |
| profileScrapeSections | array of strings | No | \["videos"] | Profile sections to scrape: "videos" and/or "reposts". |
| profileSorting | string | No | "latest" | Profile video sorting: "latest", "popular", or "oldest". Date filters only work with "latest" and "oldest". |
| oldestPostDateUnified | string | No | — | Optional filter. Only videos uploaded after or on this date will be scraped. Supports absolute (YYYY‑MM‑DD) or relative (e.g., “5 days”, “2 weeks”). |
| newestPostDate | string | No | — | Optional filter. Only videos uploaded before or on this date will be scraped. Supports absolute (YYYY‑MM‑DD) or relative (e.g., “5 days”, “2 weeks”). |
| excludePinnedPosts | boolean | No | false | Tick to exclude pinned posts from profiles. |
| proxyConfiguration | object | No | {"useApifyProxy": false} | Choose which proxies to use. If TikTok rejects the request, it will automatically fallback to datacenter proxy, then residential proxy with 3 retries. |

#### Example output JSON (Dataset record)

```json
{
  "videoWebUrl": "https://www.tiktok.com/@mrbeast/video/7578547467189374239",
  "submittedVideoUrl": "https://www.tiktok.com/@mrbeast/video/7578547467189374239",
  "input": "https://www.tiktok.com/@mrbeast/video/7578547467189374239",
  "cid": "7578605549794034443",
  "createTime": 1732995615,
  "createTimeISO": "2025-11-30T19:40:15.000Z",
  "text": "mr beast are you ok ?",
  "diggCount": 7633,
  "likedByAuthor": false,
  "pinnedByAuthor": false,
  "repliesToId": null,
  "replyCommentTotal": 100,
  "uid": "7516601022924489733",
  "uniqueId": "amin.hrizi4",
  "avatarThumbnail": "https://p16-sign-va.tiktokcdn.com/...",
  "mentions": [],
  "detailedMentions": [],
  "replies": []
}
```

Notes:

- Replies are returned as an array of objects with the same fields (excluding the nested replies array).
- A full array of all comments is also written to the key‑value store at output.json.

### FAQ

#### How many comments can I scrape per video?

Set commentsPerPost to your desired limit. The actor fetches up to that maximum per video, subject to TikTok’s API and pagination behavior.

#### Can I scrape comments from multiple videos at once?

Yes. Add multiple URLs to postURLs and the actor will process them in one run. This makes it a practical TikTok comments export tool for batch jobs.

#### Can it also get replies to comments?

Yes. Set maxRepliesPerComment to a value greater than 0 to fetch replies for each comment (up to your limit). Reply objects include timestamps, text, and commenter info.

#### What happens if TikTok blocks requests?

The actor uses an automatic proxy fallback: it starts with no proxy, then switches to a datacenter proxy, and finally to a residential proxy with up to 3 retries. Once on residential, it stays there for remaining requests.

#### Does it support scraping by profile instead of specific URLs?

Yes. Provide usernames in profiles and configure resultsPerPage, profileScrapeSections ("videos", "reposts"), profileSorting, and optional date filters to discover videos before scraping comments.

#### Is this a TikTok comments API alternative?

Yes. It’s a TikTok comments scraper — no official API required — that outputs structured JSON you can integrate into pipelines or analyze directly.

#### Can I export results to CSV?

Yes. Results are stored in the Apify Dataset as JSON records. From there, you can export to CSV or JSON and integrate with analytics tools.

#### Is login or a browser extension required?

No. This is a cloud-based TikTok comments extractor — no TikTok comment scraper Chrome extension or login is required for public content.

### Closing CTA / Final thoughts

Tiktok Comments Scraper is built for accurate, scalable extraction of TikTok video comments and replies. With profile-based video discovery, structured JSON output, and resilient proxy handling, it’s ideal for marketers, developers, analysts, and researchers who need a dependable TikTok comment crawler. Run it on Apify to scrape TikTok comments, download TikTok comments with timestamps, and export data to your analytics stack. Developers can access the Dataset via API for a streamlined TikTok comment scraper Python workflow and automation. Start extracting smarter, structured insights from TikTok today.

# Actor input Schema

## `postURLs` (type: `array`):

Add the video URLs you want to extract comments from. Enter URLs one by one or edit it in bulk.

## `commentsPerPost` (type: `integer`):

The number of comments extracted from every result. Due to TikTok API limitations, the actual number of scraped comments may differ, especially for posts with thousands of comments.

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

The maximum number of replies you want from a single comment. Note: Successful extraction of all desired replies is currently not guaranteed.

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

Add one or multiple TikTok usernames you want to scrape. You can enter the usernames one by one, or use the Bulk edit section to add a prepared list.

## `resultsPerPage` (type: `integer`):

Add the number of videos you want to scrape per profile.

## `profileScrapeSections` (type: `array`):

If a profile has reposted videos, you can scrape them by selecting Reposts

## `profileSorting` (type: `string`):

Select: Latest / Oldest / Popular. Date filters only work with Latest and Oldest.

## `oldestPostDateUnified` (type: `string`):

Optional filter. Only videos uploaded after or on this date will be scraped. Supports absolute date (YYYY-MM-DD) or relative date (e.g. 5 days, 2 weeks).

## `newestPostDate` (type: `string`):

Optional filter. Only videos uploaded before or on this date will be scraped. Supports absolute date (YYYY-MM-DD) or relative date (e.g. 5 days, 2 weeks).

## `excludePinnedPosts` (type: `boolean`):

Tick to exclude pinned posts from profiles. Pinned posts are usually the first videos on a profile's page.

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

Choose which proxies to use. If TikTok rejects the request, it will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "postURLs": [
    "https://www.tiktok.com/@mrbeast/video/7578547467189374239"
  ],
  "commentsPerPost": 100,
  "maxRepliesPerComment": 3,
  "profiles": [
    "mrbeast"
  ],
  "resultsPerPage": 10,
  "profileScrapeSections": [
    "videos"
  ],
  "profileSorting": "latest",
  "excludePinnedPosts": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "postURLs": [
        "https://www.tiktok.com/@mrbeast/video/7578547467189374239"
    ],
    "profiles": [
        "mrbeast"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperx/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 = {
    "postURLs": ["https://www.tiktok.com/@mrbeast/video/7578547467189374239"],
    "profiles": ["mrbeast"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperx/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/@mrbeast/video/7578547467189374239"
  ],
  "profiles": [
    "mrbeast"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperx/tiktok-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Comments Scraper",
        "description": "💬 TikTok Comments Scraper pulls comments, usernames, timestamps, likes, and reply threads from any TikTok post. ⚡ Fast & accurate, with CSV/JSON exports and API-ready output. 📊 Ideal for social listening, UGC mining, competitor analysis & influencer marketing.",
        "version": "0.1",
        "x-build-id": "Lom1XlsHUP3RirhUM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~tiktok-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-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/scraperx~tiktok-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-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/scraperx~tiktok-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-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",
                "properties": {
                    "postURLs": {
                        "title": "TikTok video URLs",
                        "type": "array",
                        "description": "Add the video URLs you want to extract comments from. Enter URLs one by one or edit it in bulk.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "commentsPerPost": {
                        "title": "Maximum comments per post",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The number of comments extracted from every result. Due to TikTok API limitations, the actual number of scraped comments may differ, especially for posts with thousands of comments.",
                        "default": 100
                    },
                    "maxRepliesPerComment": {
                        "title": "Maximum replies per comment",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of replies you want from a single comment. Note: Successful extraction of all desired replies is currently not guaranteed.",
                        "default": 3
                    },
                    "profiles": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Add one or multiple TikTok usernames you want to scrape. You can enter the usernames one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerPage": {
                        "title": "💯 Number of videos per profile",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Add the number of videos you want to scrape per profile.",
                        "default": 10
                    },
                    "profileScrapeSections": {
                        "title": "Profile sections to scrape",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "If a profile has reposted videos, you can scrape them by selecting Reposts",
                        "items": {
                            "type": "string",
                            "enum": [
                                "videos",
                                "reposts"
                            ]
                        },
                        "default": [
                            "videos"
                        ]
                    },
                    "profileSorting": {
                        "title": "Profile video sorting",
                        "enum": [
                            "latest",
                            "popular",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Select: Latest / Oldest / Popular. Date filters only work with Latest and Oldest.",
                        "default": "latest"
                    },
                    "oldestPostDateUnified": {
                        "title": "Scrape profile videos published after [date]",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional filter. Only videos uploaded after or on this date will be scraped. Supports absolute date (YYYY-MM-DD) or relative date (e.g. 5 days, 2 weeks)."
                    },
                    "newestPostDate": {
                        "title": "Scrape videos published before [date]",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional filter. Only videos uploaded before or on this date will be scraped. Supports absolute date (YYYY-MM-DD) or relative date (e.g. 5 days, 2 weeks)."
                    },
                    "excludePinnedPosts": {
                        "title": "Exclude pinned posts",
                        "type": "boolean",
                        "description": "Tick to exclude pinned posts from profiles. Pinned posts are usually the first videos on a profile's page.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. If TikTok rejects the request, it will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
