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

Extract TikTok comments. Just add a TikTok URL and get TikTok video and profile data: comments, URLs, numbers of shares, followers, hashtags, hearts, video, and music metadata. Export scraped data, run the scraper via API, schedule and monitor runs or integrate with other tools.

- **URL**: https://apify.com/clockworks/tiktok-comments-scraper.md
- **Developed by:** [Clockworks](https://apify.com/clockworks) (Apify)
- **Categories:** Social media, Videos
- **Stats:** 32,508 total users, 2,898 monthly users, 98.0% runs succeeded, 367 bookmarks
- **User rating**: 4.62 out of 5 stars

## Pricing

from $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.
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

### What is TikTok Comments Scraper?

TikTok Comments Scraper is a simple and powerful tool that allows you to **scrape comments from TikTok videos**: comment text, user ID, timestamp, number of replies and replies content, number of likes, etc. To get TikTok comments, just **insert the video URL or TikTok username and click the *Save & Start* button**.

### How to scrape TikTok with TikTok Comments Scraper

TikTok Comments Scraper was designed to be easy to start with, even if you’ve never extracted data from the web before. Here’s how you can scrape TikTok comments data with this tool:

1. [Create](https://console.apify.com/admin/users/FMjDZzAwFoRhp3yaf/sign-up) a free Apify account using your email.
2. Open [TikTok Comments Scraper.](https://apify.com/clockworks/tiktok-comments-scraper)
3. Add one or more TikTok video URLs to scrape comments. Alternatively, add one ore more TikTok usernames whose videos' comments you want to scrape.
4. Click _Start_ and wait for the data to be extracted.
5. Export TikTok comments in JSON, XML, CSV, Excel, or HTML.

Watch this guide to run TikTok Comments Scraper smoothly:

https://www.youtube.com/watch?v=g1HX0DeboQU

### Input

The input for TikTok Comments Scraper should be a **TikTok video URL** or **TikTok username** and **number of comments**. You can add one or multiple URLs or usernames. Here’s how it looks like:

![TikTok Comments Scraper Input](https://raw.githubusercontent.com/apify-projects/actor-readme-images/master/tiktok_comments_input.png)

You can, of course, write the input in JSON too. It’s simple:

```json
{
    "maxRepliesPerComment": 2,
    "postURLs": ["https://www.tiktok.com/@bellapoarch/video/6862153058223197445"],
    "commentsPerPost": 100
}
````

### Output

This TikTok comment finder will get you a database of results. See example below.

![TikTok Comments Scraper Output](https://raw.githubusercontent.com/apify-projects/actor-readme-images/refs/heads/master/tiktok_comments_new_input.png)

Click on *Export XY results* to download your data from this TikTok comment finder tool in XML, CSV, Excel, HTML, or JSON, as shown below.

```json
{
    "text": "Bella poarch -67.3M\nRiver flows in you -55.5M\nMirror guy -53.3M\nLeah halton -53.2M\nStawberry chocholate -50.7M",
    "diggCount": 246,
    "replyCommentTotal": 3,
    "createTimeISO": "2024-08-06T11:21:16.000Z",
    "uniqueId": "rizqirxq",
    "videoWebUrl": "https://www.tiktok.com/@bellapoarch/video/6862153058223197445",
    "uid": "6904063862041396225",
    "cid": "7399984975553086214",
    "avatarThumbnail": "https://p77-sign-va.tiktokcdn.com/tos-maliva-avt-0068/5e2902b2db8018cbbde7a1aed077a35a~c5_100x100.jpg?lk3s=30310797&nonce=98619&refresh_token=fc34fd41c37618135499867e61bb948b&x-expires=1723125600&x-signature=2ei997Hv96D%2BjKrFEhd91Uk9AyI%3D&shp=30310797&shcp=-"
}
```

### How can I use the data extracted with TikTok Comments Scraper?

✨ Find authentic **product reviews** and conduct **sentiment analysis**

👩‍🔬 Get data for research and **social listening** experiments

🦠 Analyze **viral campaigns** and trends

🥸 **Identify unverified content** and inaccurate information with high public value

📚 Prepare for or analyze a **TikTok marketing campaign**

### Integrate TikTok Comments Scraper and automate your workflow

Last but not least, TikTok Scraper can be connected with almost any cloud service or web app thanks to [integrations](https://apify.com/integrations) on the Apify platform</a>.

These include:

- [Make](https://docs.apify.com/platform/integrations/make)
- [Zapier](https://docs.apify.com/platform/integrations/zapier)
- [Slack](https://docs.apify.com/platform/integrations/slack)
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte)
- [GitHub](https://docs.apify.com/platform/integrations/github)
- [Google Drive](https://docs.apify.com/platform/integrations/drive)
- and [much more](https://docs.apify.com/platform/integrations).

Alternatively, you can use [webhooks](https://docs.apify.com/platform/integrations/webhooks) to carry out an action whenever an event occurs, e.g. get a notification whenever TikTok Scraper successfully finishes a run.

### Scrape any TikTok data you need with dedicated scrapers

You can use the dedicated scrapers below if you want to **scrape specific TikTok data**. Each of them is built particularly for the relevant TikTok data scraping case, be it hashtags, search results, profiles, or all data at once. Feel free to browse them:

<table>
<tr>
<td>🎹 <a href="https://apify.com/clockworks/tiktok-scraper">Tiktok Scraper</a></td>
<td>📹 <a href="https://apify.com/clockworks/tiktok-video-scraper">Tiktok Video Scraper</a></td>
<td>🧛 <a href="https://apify.com/clockworks/tiktok-profile-scraper">TikTok Profile Scraper</a></td>
<td>🎸 <a href="https://apify.com/clockworks/tiktok-sound-scraper">Tiktok Sound Scraper</a></td>
</tr>
<tr>
<td>📊 <a href="https://apify.com/clockworks/free-tiktok-scraper">TikTok Data Extractor</a></td>
<td>🛍 <a href="https://apify.com/clockworks/tiktok-ads-scraper">Tiktok Ads Scraper</a></td>
<td>#️⃣ <a href="https://apify.com/clockworks/tiktok-hashtag-scraper">TikTok Hashtag Scraper</a></td>

<td>🔍<a href="https://apify.com/clockworks/tiktok-discover-scraper">TikTok Discover Scraper</a></td>
</tr>
</table>

### Not your cup of tea? Build your own scraper

TikTok Comments Scraper doesn’t exactly do what you need?

You can always build your own! Use one of [scraper templates](https://apify.com/templates) in Python, JavaScript, and TypeScript to get started.

Alternatively, you can write it from scratch using our [open-source library Crawlee](https://crawlee.dev/). You can keep the scraper to yourself or make it public by adding it to Apify Store and [start making money](https://blog.apify.com/how-to-scrape-tiktok-tutorial/) on it.

Or let us know if you need a [custom scraping solution](https://apify.com/custom-solutions).

### Your feedback

We’re always working on improving the performance of our Actors. So if you’ve got any technical feedback for TikTok Comments Scraper or simply found a bug, please create an issue on the Actor’s [Issues tab](https://apify.com/clockworks/tiktok-comments-scraper/issues/open) in Apify Console.

### Error items

When the scraper cannot retrieve data for a given input — for example a profile is private or a post has been deleted — it pushes an **error item** to the dataset instead of silently skipping it. Normal output items are never affected; you can tell them apart by the presence of an `errorCode` field.

#### Error item structure

```json
{
    "url": "https://www.tiktok.com/@someuser",
    "input": "someuser",
    "error": "Profile is private",
    "errorCode": "PROFILE_PRIVATE"
}
```

#### Error codes reference

| `errorCode`                      | Meaning                                                        |
| -------------------------------- | -------------------------------------------------------------- |
| `NOT_FOUND`                      | Profile or hashtag does not exist                              |
| `POST_NOT_FOUND_OR_PRIVATE`      | Post URL is gone or private                                    |
| `POST_SENSITIVE`                 | Post is flagged as sensitive content                           |
| `NO_TRENDING_FOR_HASHTAG`        | No ads found for this hashtag                                  |
| `MUSIC_NOT_FOUND`                | No videos found for the music tag                              |
| `SEARCH_QUERY_NOT_FOUND`         | No videos found for the search query                           |
| `SEARCH_QUERY_PROFILE_NOT_FOUND` | No profiles found for the search query                         |
| `FILTER_NO_PASS`                 | Videos exist but none match the active date/popularity filters |
| `PROFILE_EMPTY`                  | Profile has no videos (or is behind a login wall)              |
| `PROFILE_REPOSTS_EMPTY`          | Profile has no reposts (or is behind a login wall)             |
| `PROFILE_FOLLOWING_EMPTY`        | Profile is not following anyone                                |
| `PROFILE_FOLLOWERS_EMPTY`        | Profile has no followers                                       |
| `PROFILE_PRIVATE`                | Profile is private                                             |
| `GOOGLE_RUN_NO_RESULTS`          | Google-assisted run returned no results                        |
| `TRENDING_EMPTY`                 | Trending page returned no results                              |
| `INVALID_INPUT`                  | Actor failed due to bad configuration (run is also terminated) |
| `INVALID_URLS`                   | One or more start URLs were malformed                          |

***

### FAQ

#### How can I use TikTok Comments Scraper with the Apify API?

The Apify API gives you programmatic access to the Apify platform. [The API](https://apify.com/clockworks/free-tiktok-scraper/api/client/nodejs) is organized around RESTful HTTP endpoints that enable you to manage, schedule, and run Apify actors. The API also lets you access any datasets, monitor actor performance, fetch results, create and update versions, and more.

To access the API using Node.js, use the `apify-client` NPM package. To access the API using Python, use the `apify-client` PyPI package.

Check out the [Apify API](https://docs.apify.com/api/v2) reference docs for full details, or click on the [TikTok Comments API](https://apify.com/clockworks/tiktok-comments-scraper/api/client/nodejs) tab for code examples.

#### Is it legal to scrape TikTok with TikTok Comments Scraper?

Our [TikTok scrapers](https://apify.com/store?search=tiktok), TikTok Comments Scraper included, are ethical and **do not extract any private user data, such as email addresses, gender, or location.** They can only extract what the user has chosen to share publicly. However, you should be aware that your results might contain personal data.

Personal data is protected by GDPR in the European Union and other laws and regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you’re unsure whether your reason is legitimate, consult your lawyers. You can also read our blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and [ethical scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/).

#### How much does it cost to use TikTok Comments Scraper?

TikTok Comments Scraper uses the Pay-per-result pricing model, so your costs can be easily calculated: it will cost you **$5 to scrape 1,000 results**, so $0.005 per item. Apify provides you with $5 free usage credits every month on the [Apify Free plan](https://apify.com/pricing), so you can **get 1,000 results from TikTok Comments Scraper for free**.

But if you need to extract data regularly, you should get an Apify subscription. We recommend our $29/month Starter plan — that one could get you **over 5,800 results from TikTok Comments Scraper** every month.

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

## `topLevelCommentsPerPost` (type: `integer`):

The maximum number of top-level (non-reply) comments you want from a single post.

## `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 <strong>Bulk edit</strong> 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 <i>Reposts</i>

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

Select:

<i>Latest</i> to scrape the most recent videos first

<i>Oldest</i> - the oldest videos first

<i>Popular</i> - the most popular videos first

Date filters only work with <i>Latest</i> and <i>Oldest</i>.

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

Optional filter. Only videos uploaded after or on this date will be scraped. Alternatively, specify how old the scraped videos should be in days. Putting <code>1</code> will get you only today's posts, <code>2</code> - yesterday's and today's, and so on.

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

Optional filter. Only videos uploaded before or on this date will be scraped.

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

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

## Actor input object example

```json
{
  "postURLs": [
    "https://www.tiktok.com/@looooooooch/video/7332342275151760642"
  ],
  "commentsPerPost": 100,
  "resultsPerPage": 100,
  "profileScrapeSections": [
    "videos"
  ],
  "profileSorting": "latest",
  "excludePinnedPosts": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all scraped data

# 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/@looooooooch/video/7332342275151760642"
    ],
    "commentsPerPost": 100,
    "maxRepliesPerComment": 0,
    "resultsPerPage": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("clockworks/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/@looooooooch/video/7332342275151760642"],
    "commentsPerPost": 100,
    "maxRepliesPerComment": 0,
    "resultsPerPage": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("clockworks/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/@looooooooch/video/7332342275151760642"
  ],
  "commentsPerPost": 100,
  "maxRepliesPerComment": 0,
  "resultsPerPage": 100
}' |
apify call clockworks/tiktok-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Comments Scraper",
        "description": "Extract TikTok comments. Just add a TikTok URL and get TikTok video and profile data: comments, URLs, numbers of shares, followers, hashtags, hearts, video, and music metadata. Export scraped data, run the scraper via API, schedule and monitor runs or integrate with other tools.",
        "version": "0.0",
        "x-build-id": "0jbxF77uUATR5SPSP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/clockworks~tiktok-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-clockworks-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/clockworks~tiktok-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-clockworks-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/clockworks~tiktok-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-clockworks-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."
                    },
                    "topLevelCommentsPerPost": {
                        "title": "Maximum top-level comments per post",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The maximum number of top-level (non-reply) comments you want from a single post."
                    },
                    "maxRepliesPerComment": {
                        "title": "Maximum replies per comment",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of replies you want from a single comment. \n\nNote: Successful extraction of all desired replies is currently not guaranteed."
                    },
                    "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 <strong>Bulk edit</strong> 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": 1
                    },
                    "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 <i>Reposts</i>",
                        "items": {
                            "type": "string",
                            "enum": [
                                "videos",
                                "reposts"
                            ],
                            "enumTitles": [
                                "Videos",
                                "Reposts"
                            ]
                        },
                        "default": [
                            "videos"
                        ]
                    },
                    "profileSorting": {
                        "title": "Profile video sorting",
                        "enum": [
                            "latest",
                            "popular",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Select: \n\n<i>Latest</i> to scrape the most recent videos first \n\n<i>Oldest</i> - the oldest videos first \n\n<i>Popular</i> - the most popular videos first \n\nDate filters only work with <i>Latest</i> and <i>Oldest</i>.",
                        "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])(T[0-2]\\d:[0-5]\\d(:[0-5]\\d)?(\\.\\d+)?Z?)?$|^(\\d+)\\s*(minute|hour|day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional filter. Only videos uploaded after or on this date will be scraped. Alternatively, specify how old the scraped videos should be in days. Putting <code>1</code> will get you only today's posts, <code>2</code> - yesterday's and today's, and so on."
                    },
                    "newestPostDate": {
                        "title": "Scrape videos published before [date]",
                        "type": "string",
                        "description": "Optional filter. Only videos uploaded before or on this date will be scraped."
                    },
                    "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
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
