# YouTube Scraper (`calm_builder/youtube-scraper`) Actor

Scrape YouTube videos, Shorts, channels, search results, and comments from URLs, channel handles, or keyword searches. Collect titles, views, publish dates, descriptions, thumbnails, channel data, and engagement insights in clean structured output.

- **URL**: https://apify.com/calm\_builder/youtube-scraper.md
- **Developed by:** [Coder](https://apify.com/calm_builder) (community)
- **Categories:** Social media, Videos, Automation
- **Stats:** 9 total users, 7 monthly users, 87.5% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 collected records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## YouTube Scraper

Collect structured public YouTube data from keywords, search result URLs, channel pages, direct video links, and Shorts links in one run.

This actor is built for research, monitoring, reporting, content analysis, automation, and dataset creation. It returns one clean record per video or Short, with optional enrichments for channel profiles, detailed item metadata, comments, and replies.

### What This Actor Can Collect

- Search results from plain-text keywords
- Search results from direct YouTube search URLs
- Videos from channel pages
- Shorts from channel pages
- Direct video records from watch URLs
- Direct Short records from Shorts URLs
- Optional channel profile information
- Optional detailed video metadata
- Optional comments and replies

### Why Teams Use It

- Track creators, brands, competitors, and topics
- Build datasets for dashboards and reporting
- Monitor search visibility for videos and Shorts
- Collect channel content for audits and research
- Enrich direct YouTube links into structured records
- Export consistent data for spreadsheets, APIs, and downstream automation

### Supported Inputs

You can mix multiple input types in the same run.

#### Search Terms And Direct Links

Use the `searchAndDirectInputs` field to provide:

- Plain search terms such as `mrbeast latest video`
- YouTube search result URLs
- YouTube watch URLs
- YouTube Shorts URLs

Example:

```text
mrbeast latest video
https://www.youtube.com/results?search_query=ai+tools+for+students
https://www.youtube.com/watch?v=dQw4w9WgXcQ
https://www.youtube.com/shorts/jCE1Ol3PYDs
````

#### Channel Inputs

Use the `channelInputs` field to provide:

- Channel handles such as `@MrBeast`
- Full YouTube channel URLs

Example:

```text
@MrBeast
https://www.youtube.com/@MrBeast
```

### Main Controls

You can control how much data the actor returns by adjusting:

- `maxVideos`
- `maxShorts`
- `maxChannelVideos`
- `maxChannelShorts`
- `includeChannelVideos`
- `includeChannelShorts`
- `channelDateRangeSortBy`
- `channelDateRangeDate`

For keyword and search URL collection, you can also apply optional search filters:

- `duration`
- `uploadDate`
- `features`
- `prioritize`

### Optional Enrichments

You can keep runs lightweight or enable deeper output when needed.

#### Channel Info

Enable `scrapeChannelInfo` to add public channel profile data where available, including fields such as:

- Channel ID
- Channel name
- Handle
- Profile URL
- Avatar URL
- Subscriber count
- Description

#### Detailed Video Data

Enable `scrapeDetailedVideoData` to add extra fields for regular videos, such as:

- Publish and upload dates
- Tags and keywords
- Category
- Chapters
- Metadata rows
- Captions availability
- Embed URL
- Additional video metadata when publicly available

#### Comments And Replies

Enable `scrapeCommentsAndReplies` to collect:

- Top-level comment threads
- Reply counts
- Replies per thread

You can control comment depth with:

- `maxCommentThreads`
- `maxRepliesPerThread`

### Output Format

Each dataset item represents one YouTube video or one YouTube Short.

Common top-level fields include:

- `inputType`
- `inputValue`
- `sourceUrl`
- `surface`
- `contentType`
- `id`
- `url`
- `title`
- `description`
- `publishedTimeText`
- `publishedDate`
- `durationText`
- `durationSeconds`
- `viewCount`
- `viewCountText`
- `likeCount`
- `commentCount`
- `thumbnailUrl`
- `thumbnails`
- `isShort`
- `isLive`
- `isUpcoming`
- `channel`
- `details`
- `comments`
- `searchContext`
- `channelContext`
- `collectedAt`
- `error`

### Example Output

```json
{
  "inputType": "search",
  "inputValue": "mrbeast latest video",
  "sourceUrl": "https://www.youtube.com/results?search_query=mrbeast+latest+video",
  "surface": "search",
  "contentType": "video",
  "id": "QJI0an6irrA",
  "url": "https://www.youtube.com/watch?v=QJI0an6irrA",
  "title": "30 Celebrities Fight For $1,000,000!",
  "description": "I was not prepared for how intense that ending was",
  "publishedTimeText": "2 months ago",
  "publishedDate": "2026-01-07T12:00:09Z",
  "durationText": "41:39",
  "durationSeconds": 2499,
  "viewCount": 114372718,
  "viewCountText": "114,372,718 views",
  "likeCount": 0,
  "commentCount": 0,
  "thumbnailUrl": "https://i.ytimg.com/vi/QJI0an6irrA/maxresdefault.jpg",
  "isShort": false,
  "channel": {
    "id": "UCX6OQ3DkcsbYNE6H8uQQuVA",
    "name": "MrBeast",
    "handle": "@MrBeast",
    "url": "https://www.youtube.com/@MrBeast"
  },
  "details": {
    "id": "QJI0an6irrA",
    "publishDate": "2026-01-07T12:00:09Z",
    "uploadDate": "2026-01-07T12:00:09Z",
    "category": "Entertainment",
    "embedUrl": "https://www.youtube.com/embed/QJI0an6irrA"
  },
  "comments": null,
  "searchContext": {
    "searchType": "keyword",
    "searchQuery": "mrbeast latest video"
  },
  "channelContext": null,
  "collectedAt": "2026-04-02T09:30:00+00:00",
  "error": null
}
```

### How To Use

1. Add search terms, YouTube URLs, channel inputs, or any combination of them.
2. Set the number of videos and Shorts you want to collect.
3. Enable optional enrichments only when you need deeper output.
4. Run the actor.
5. Export the dataset in JSON, CSV, Excel, or use it directly through the Apify API.

### Best Use Cases

- SEO and visibility tracking
- Creator and competitor monitoring
- Topic and trend research
- Content strategy analysis
- Media and brand intelligence
- Dataset generation for internal tools
- Automation workflows and reporting pipelines

### Notes

- This actor works with publicly available YouTube data.
- Available fields may vary by page type, content type, and public availability.
- Search surfaces, channel pages, videos, and Shorts do not always expose the same metadata.
- Comment availability depends on the target item and whether comments are publicly available.
- Detailed metadata is richer for regular videos than for Shorts.

### FAQ

#### Can I use keywords and URLs in the same run?

Yes. You can combine search terms, search URLs, watch URLs, Shorts URLs, and channel inputs in a single run.

#### Does this actor support both videos and Shorts?

Yes. Videos and Shorts are supported separately, and you can set different limits for each.

#### Can I collect from channel pages?

Yes. You can collect from channel Videos and Shorts surfaces independently.

#### Can I filter channel results by date?

Yes. You can use `channelDateRangeDate` and `channelDateRangeSortBy` to control channel-based collection.

#### Can I collect comments and replies?

Yes. Enable `scrapeCommentsAndReplies` and choose your limits for threads and replies.

#### Is the output suitable for automation?

Yes. The dataset is structured for exports, APIs, analysis workflows, and downstream processing.

# Actor input Schema

## `searchAndDirectInputs` (type: `array`):

Add one value per row. Supported values: plain search terms, YouTube search-result URLs, direct video URLs, and Short URLs.

## `maxVideos` (type: `integer`):

Maximum number of regular videos to collect for each search term or supported direct link. Set to `0` to disable video collection.

## `maxShorts` (type: `integer`):

Maximum number of Shorts to collect for each search term or supported direct link. Set to `0` to disable Shorts collection.

## `scrapeChannelInfo` (type: `boolean`):

Include available public channel profile data for results collected from search terms, search-result URLs, direct video URLs, and direct Short URLs.

## `channelInputs` (type: `array`):

Add one value per row. Supported values: channel handles such as `@MrBeast` and full YouTube channel URLs.

## `includeChannelVideos` (type: `boolean`):

Collect items from the channel's Videos tab.

## `includeChannelShorts` (type: `boolean`):

Collect items from the channel's Shorts tab.

## `maxChannelVideos` (type: `integer`):

Maximum number of regular videos to collect from each channel. Set to `0` to disable channel video collection.

## `maxChannelShorts` (type: `integer`):

Maximum number of Shorts to collect from each channel. Set to `0` to disable channel Shorts collection.

## `channelDateRangeSortBy` (type: `string`):

Choose how channel video and Short results should be ordered. If a channel date range is set, sorting is automatically forced to Latest.

## `channelDateRangeDate` (type: `string`):

Optional publish-time filter for channel video and Short results. Use either an absolute date (`YYYY-MM-DD`) or a relative value such as `2 weeks`, `3 months`, or `1 year`. If set, channel sorting is automatically changed to Latest. Leave empty to skip this filter.

## `scrapeDetailedVideoData` (type: `boolean`):

Collect extra video-only data such as metadata rows, tags, keywords, chapters, and other watch-page details where available. This enrichment is intended for regular videos, not Shorts.

## `scrapeCommentsAndReplies` (type: `boolean`):

Collect top-level comments and replies for videos and Shorts where comments are available.

## `maxCommentThreads` (type: `integer`):

Maximum number of top-level comment threads to collect for each video or Short.

## `maxRepliesPerThread` (type: `integer`):

Maximum number of replies to collect for each top-level comment thread. Set to `0` to disable reply collection.

## `commentsSortBy` (type: `string`):

Choose how comments should be ordered. If a comments date range is set, sorting is automatically forced to Newest. Very recent comments can take a short time to appear, so comments posted within roughly the last minute may occasionally be missed in the same run.

## `commentsDateRangeDate` (type: `string`):

Optional publish-time filter for comments and replies. Use either an absolute date (`YYYY-MM-DD`) or a relative value such as `1 day`, `2 weeks`, `3 months`, or `1 year`. If set, comment sorting is automatically changed to Newest. Very recent comments can take a short time to appear, so comments posted within roughly the last minute may occasionally be missed in the same run. Leave empty to skip this filter.

## Actor input object example

```json
{
  "searchAndDirectInputs": [
    "mrbeast latest video",
    "https://www.youtube.com/results?search_query=ai+tools+for+students",
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/shorts/jCE1Ol3PYDs"
  ],
  "maxVideos": 10,
  "maxShorts": 10,
  "scrapeChannelInfo": false,
  "channelInputs": [
    "@MrBeast",
    "https://www.youtube.com/@MrBeast"
  ],
  "includeChannelVideos": true,
  "includeChannelShorts": true,
  "maxChannelVideos": 10,
  "maxChannelShorts": 10,
  "channelDateRangeSortBy": "latest",
  "channelDateRangeDate": "",
  "scrapeDetailedVideoData": false,
  "scrapeCommentsAndReplies": false,
  "maxCommentThreads": 10,
  "maxRepliesPerThread": 10,
  "commentsSortBy": "top",
  "commentsDateRangeDate": ""
}
```

# Actor output Schema

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

Dataset items in their full JSON form. Use this for browsing, exports, API integrations, and automation.

# 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 = {
    "searchAndDirectInputs": [
        "mrbeast latest video",
        "https://www.youtube.com/results?search_query=ai+tools+for+students",
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/shorts/jCE1Ol3PYDs"
    ],
    "channelInputs": [
        "@MrBeast",
        "https://www.youtube.com/@MrBeast"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("calm_builder/youtube-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 = {
    "searchAndDirectInputs": [
        "mrbeast latest video",
        "https://www.youtube.com/results?search_query=ai+tools+for+students",
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/shorts/jCE1Ol3PYDs",
    ],
    "channelInputs": [
        "@MrBeast",
        "https://www.youtube.com/@MrBeast",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("calm_builder/youtube-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 '{
  "searchAndDirectInputs": [
    "mrbeast latest video",
    "https://www.youtube.com/results?search_query=ai+tools+for+students",
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/shorts/jCE1Ol3PYDs"
  ],
  "channelInputs": [
    "@MrBeast",
    "https://www.youtube.com/@MrBeast"
  ]
}' |
apify call calm_builder/youtube-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Scraper",
        "description": "Scrape YouTube videos, Shorts, channels, search results, and comments from URLs, channel handles, or keyword searches. Collect titles, views, publish dates, descriptions, thumbnails, channel data, and engagement insights in clean structured output.",
        "version": "0.0",
        "x-build-id": "dl5uAmDsOd0tylLFO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/calm_builder~youtube-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-calm_builder-youtube-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/calm_builder~youtube-scraper/runs": {
            "post": {
                "operationId": "runs-sync-calm_builder-youtube-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/calm_builder~youtube-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-calm_builder-youtube-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": {
                    "searchAndDirectInputs": {
                        "title": "Search terms and direct links",
                        "type": "array",
                        "description": "Add one value per row. Supported values: plain search terms, YouTube search-result URLs, direct video URLs, and Short URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideos": {
                        "title": "Maximum videos per search term or link",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of regular videos to collect for each search term or supported direct link. Set to `0` to disable video collection.",
                        "default": 10
                    },
                    "maxShorts": {
                        "title": "Maximum Shorts per search term or link",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of Shorts to collect for each search term or supported direct link. Set to `0` to disable Shorts collection.",
                        "default": 10
                    },
                    "scrapeChannelInfo": {
                        "title": "Add channel info for search and direct results",
                        "type": "boolean",
                        "description": "Include available public channel profile data for results collected from search terms, search-result URLs, direct video URLs, and direct Short URLs.",
                        "default": false
                    },
                    "channelInputs": {
                        "title": "Channel handles and links",
                        "type": "array",
                        "description": "Add one value per row. Supported values: channel handles such as `@MrBeast` and full YouTube channel URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeChannelVideos": {
                        "title": "Include channel videos",
                        "type": "boolean",
                        "description": "Collect items from the channel's Videos tab.",
                        "default": true
                    },
                    "includeChannelShorts": {
                        "title": "Include channel Shorts",
                        "type": "boolean",
                        "description": "Collect items from the channel's Shorts tab.",
                        "default": true
                    },
                    "maxChannelVideos": {
                        "title": "Maximum videos per channel",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of regular videos to collect from each channel. Set to `0` to disable channel video collection.",
                        "default": 10
                    },
                    "maxChannelShorts": {
                        "title": "Maximum Shorts per channel",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of Shorts to collect from each channel. Set to `0` to disable channel Shorts collection.",
                        "default": 10
                    },
                    "channelDateRangeSortBy": {
                        "title": "Channel sort",
                        "enum": [
                            "latest",
                            "popular",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Choose how channel video and Short results should be ordered. If a channel date range is set, sorting is automatically forced to Latest.",
                        "default": "latest"
                    },
                    "channelDateRangeDate": {
                        "title": "Channel date range",
                        "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 publish-time filter for channel video and Short results. Use either an absolute date (`YYYY-MM-DD`) or a relative value such as `2 weeks`, `3 months`, or `1 year`. If set, channel sorting is automatically changed to Latest. Leave empty to skip this filter.",
                        "default": ""
                    },
                    "scrapeDetailedVideoData": {
                        "title": "Add detailed data for videos",
                        "type": "boolean",
                        "description": "Collect extra video-only data such as metadata rows, tags, keywords, chapters, and other watch-page details where available. This enrichment is intended for regular videos, not Shorts.",
                        "default": false
                    },
                    "scrapeCommentsAndReplies": {
                        "title": "Add comments and replies",
                        "type": "boolean",
                        "description": "Collect top-level comments and replies for videos and Shorts where comments are available.",
                        "default": false
                    },
                    "maxCommentThreads": {
                        "title": "Maximum comment threads per item",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of top-level comment threads to collect for each video or Short.",
                        "default": 10
                    },
                    "maxRepliesPerThread": {
                        "title": "Maximum replies per thread",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of replies to collect for each top-level comment thread. Set to `0` to disable reply collection.",
                        "default": 10
                    },
                    "commentsSortBy": {
                        "title": "Comments sort",
                        "enum": [
                            "top",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Choose how comments should be ordered. If a comments date range is set, sorting is automatically forced to Newest. Very recent comments can take a short time to appear, so comments posted within roughly the last minute may occasionally be missed in the same run.",
                        "default": "top"
                    },
                    "commentsDateRangeDate": {
                        "title": "Comments date range",
                        "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 publish-time filter for comments and replies. Use either an absolute date (`YYYY-MM-DD`) or a relative value such as `1 day`, `2 weeks`, `3 months`, or `1 year`. If set, comment sorting is automatically changed to Newest. Very recent comments can take a short time to appear, so comments posted within roughly the last minute may occasionally be missed in the same run. Leave empty to skip this filter.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
