# Dailymotion Scraper (`solidcode/dailymotion-scraper`) Actor

\[💰 $4.00 / 1K] Extract Dailymotion videos, channels, and playlists by search term or URL — titles, views, likes, durations, upload dates, channel info, and optional comments.

- **URL**: https://apify.com/solidcode/dailymotion-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Videos, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 videos

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

## Dailymotion Scraper

Pull videos, channels, playlists, and comments from Dailymotion at scale — titles, view and like counts, durations, upload dates, descriptions, tags, channel follower counts, and per-video comment threads. Mix search terms and direct links in one run, with every row tagged by type so videos, channels, and playlists stay cleanly separated. Built for media researchers, marketers, and data teams who need structured Dailymotion data without collecting it by hand one page at a time.

### Why This Scraper?

- **Four record types in one run** — videos, channels, playlists, and comments, each tagged with a `recordType` field so a mixed search stays filterable downstream.
- **Three search modes** — point a plain keyword at videos, channels, or playlists with a single dropdown; no separate runs, no URL crafting.
- **Search terms and links in the same input** — paste a video, channel, or playlist URL alongside keywords; each entry is auto-routed to the right extractor.
- **Accurate view and like counts via per-video enrichment** — channel and playlist videos are individually enriched so you get real `viewCount`, `likeCount`, `category`, and `tags`, not just the thin numbers search pages expose.
- **Five upload-date windows** — Any time, Today, This week, This month, or This year, computed against the moment your run starts.
- **Second-precision duration filters** — `minDurationSeconds` and `maxDurationSeconds` let you isolate shorts, mid-length clips, or long-form content exactly, not in rough minute buckets.
- **Three sort orders** — Most relevant, Most recent, or Most viewed, so you can surface trending uploads or the all-time top performers per query.
- **Optional comment threads with a per-video cap** — flip on comments to get each comment's `text`, author name, author ID, and timestamp as its own row, bounded by `maxCommentsPerVideo` so a viral video can't run away with your run.
- **Per-query result cap** — `maxResults` bounds every search term, channel, and playlist independently, so one large channel won't dominate the whole job.

### Use Cases

**Media & Content Research**
- Track which topics and creators are trending by sorting on Most viewed
- Build a dataset of long-form vs. short-form uploads using duration filters
- Monitor a channel's full back-catalogue of videos and playlists
- Map a topic's coverage across channels with a single keyword search

**Marketing & Competitive Intelligence**
- Benchmark a competitor channel's follower count, video count, and view totals
- Find the most-viewed videos for a product or brand keyword
- Spot rising creators in a niche before they hit the mainstream
- Compare engagement (views vs. likes) across rival channels

**Audience & Sentiment Analysis**
- Pull comment threads to gauge viewer reaction to specific videos
- Collect commenter names and timestamps for community research
- Track sentiment shifts across a channel's recent uploads
- Mine comment text and authors on high-traffic videos for recurring themes

**Data & Trend Monitoring**
- Feed fresh upload metadata into dashboards and BI tools
- Build time-series datasets of view growth using repeated runs
- Assemble playlist inventories for content-licensing research
- Localize trend tracking with date-windowed searches

### Getting Started

#### Simple Keyword Search

The simplest run — one keyword, 50 video results:

```json
{
    "queries": ["breaking news"],
    "searchType": "videos",
    "maxResults": 50
}
````

#### Scrape a Channel by URL

Paste a channel link to pull its videos. Mix in a playlist URL if you like — each entry is routed automatically:

```json
{
    "queries": [
        "https://www.dailymotion.com/dailymotionUS",
        "https://www.dailymotion.com/playlist/x7xr3p"
    ],
    "maxResults": 200
}
```

#### Filtered Video Search

Recent, long-form videos sorted newest-first:

```json
{
    "queries": ["documentary"],
    "searchType": "videos",
    "sortBy": "recent",
    "uploadDate": "month",
    "minDurationSeconds": 600,
    "maxResults": 100
}
```

#### Videos with Comments

Pull videos for a topic and collect up to 20 comments on each:

```json
{
    "queries": ["product review"],
    "searchType": "videos",
    "includeComments": true,
    "maxCommentsPerVideo": 20,
    "maxResults": 50
}
```

#### Search for Channels

Switch the search mode to return channels instead of videos:

```json
{
    "queries": ["sports", "cooking"],
    "searchType": "channels",
    "maxResults": 30
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `queries` | string\[] | — | Search terms (e.g. "breaking news") or Dailymotion links — a video, channel, or playlist URL. Each entry is processed on its own; search terms return search results, URLs return that item and its contents. |
| `searchType` | select | `Videos` | For plain search terms, what kind of result to return: Videos, Channels, or Playlists. Ignored when you paste a direct link. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum results per query, per channel, or per playlist. Set to `0` to collect everything — use with care, large channels can hold thousands of videos. |
| `sortBy` | select | `Most relevant` | Ordering for search results: Most relevant, Most recent, or Most viewed. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `uploadDate` | select | `Any time` | Only include videos uploaded within this window: Any time, Today, This week, This month, or This year. |
| `minDurationSeconds` | integer | null | Only include videos at least this many seconds long. Leave empty for no minimum. |
| `maxDurationSeconds` | integer | null | Only include videos at most this many seconds long. Leave empty for no maximum. |
| `includeComments` | boolean | `false` | Also collect comments for each video as separate rows. Adds results and increases cost. Off by default. |
| `maxCommentsPerVideo` | integer | `50` | When comments are on, the cap on comments collected per video. Set to `0` to collect all comments. |

### Output

Every row carries a `recordType` field — `video`, `channel`, `playlist`, or `comment` — so you can filter cleanly downstream. Each `query` field records the search term or URL that produced the row.

#### Video (`recordType: "video"`)

```json
{
    "recordType": "video",
    "id": "x8abcde",
    "url": "https://www.dailymotion.com/video/x8abcde",
    "title": "Breaking News: Top Stories Today",
    "description": "The biggest headlines from around the world...",
    "durationSeconds": 312,
    "viewCount": 48210,
    "likeCount": 1240,
    "commentCount": 86,
    "createdAt": "2026-05-18T09:14:00Z",
    "thumbnailUrl": "https://s1.dmcdn.net/v/example/x720.jpg",
    "tags": ["news", "world"],
    "category": "News",
    "isLive": false,
    "channelId": "x1ab2c",
    "channelName": "Dailymotion US",
    "channelUrl": "https://www.dailymotion.com/dailymotionUS",
    "query": "breaking news"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"video"` |
| `id` | string | Dailymotion video ID |
| `url` | string | Canonical video URL |
| `title` | string | Video title |
| `description` | string | Video description |
| `durationSeconds` | integer | Length in seconds |
| `viewCount` | integer | Total views (enriched on channel/playlist videos) |
| `likeCount` | integer | Total likes |
| `commentCount` | integer | Total comments on the video (null on plain search rows; populated on direct video URLs and channel/playlist videos) |
| `createdAt` | string | Upload timestamp (ISO 8601) |
| `thumbnailUrl` | string | Primary thumbnail image |
| `tags` | string\[] | Hashtags and tags |
| `category` | string | Content category label |
| `isLive` | boolean | Whether the video is a live stream |
| `channelId` | string | Owner channel ID |
| `channelName` | string | Owner channel display name |
| `channelUrl` | string | Owner channel URL |
| `query` | string | The search term or URL that produced this row |

#### Channel (`recordType: "channel"`)

```json
{
    "recordType": "channel",
    "id": "x1ab2c",
    "url": "https://www.dailymotion.com/dailymotionUS",
    "name": "Dailymotion US",
    "username": "dailymotionUS",
    "description": "Official US channel...",
    "avatarUrl": "https://s2.dmcdn.net/A_avatar.jpg",
    "followerCount": 152340,
    "videoCount": 4821,
    "createdAt": null,
    "query": "https://www.dailymotion.com/dailymotionUS"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"channel"` |
| `id` | string | Channel ID |
| `url` | string | Channel URL |
| `name` | string | Channel display name |
| `username` | string | Channel handle / screen name |
| `description` | string | Channel description |
| `avatarUrl` | string | Avatar image URL |
| `followerCount` | integer | Number of followers |
| `videoCount` | integer | Number of videos on the channel |
| `createdAt` | string | Channel creation timestamp when available |
| `query` | string | The search term or URL that produced this row |

#### Playlist (`recordType: "playlist"`)

```json
{
    "recordType": "playlist",
    "id": "x7xr3p",
    "url": "https://www.dailymotion.com/playlist/x7xr3p",
    "name": "Top Documentaries",
    "description": "A curated set of long-form documentaries...",
    "videoCount": 42,
    "thumbnailUrl": "https://s1.dmcdn.net/p/example.jpg",
    "channelId": "x1ab2c",
    "channelName": "Dailymotion US",
    "createdAt": "2025-11-02T12:00:00Z",
    "query": "https://www.dailymotion.com/playlist/x7xr3p"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"playlist"` |
| `id` | string | Playlist ID |
| `url` | string | Playlist URL |
| `name` | string | Playlist title |
| `description` | string | Playlist description |
| `videoCount` | integer | Number of videos in the playlist |
| `thumbnailUrl` | string | Cover thumbnail image |
| `channelId` | string | Owner channel ID |
| `channelName` | string | Owner channel name |
| `createdAt` | string | Playlist creation timestamp |
| `query` | string | The search term or URL that produced this row |

#### Comment (`recordType: "comment"`)

Emitted only when `includeComments: true`. Capped at `maxCommentsPerVideo` per video.

```json
{
    "recordType": "comment",
    "id": "comment-12345",
    "videoId": "x8abcde",
    "videoUrl": "https://www.dailymotion.com/video/x8abcde",
    "text": "Great coverage, thanks for sharing!",
    "authorName": "Jordan R.",
    "authorId": "x9zy8w",
    "createdAt": "2026-05-19T16:42:00Z",
    "query": "breaking news"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"comment"` |
| `id` | string | Comment ID |
| `videoId` | string | Parent video ID |
| `videoUrl` | string | Parent video URL |
| `text` | string | Comment body |
| `authorName` | string | Commenter display name |
| `authorId` | string | Commenter ID |
| `createdAt` | string | Comment timestamp (ISO 8601) |
| `query` | string | The search term or URL that produced the parent video |

### Tips for Best Results

- **Start small.** Set `maxResults` to 25–50 on your first run to confirm the data matches your needs, then scale up.
- **Mix searches and links freely.** A single run can hold keywords, channel URLs, and playlist URLs together — each entry is routed to the right extractor automatically.
- **Sort and filter for the videos connection.** `sortBy`, `uploadDate`, and the duration filters apply to video searches. Channel and playlist searches return their items directly, so those filters are ignored there.
- **Leave comments off unless you need them.** Comments add a row per comment and raise cost. On channel and playlist runs, comments are pulled for every video collected, so total cost scales with videos × comments — `maxResults` caps the videos, not the comments. For example, a channel run with `maxResults: 100`, `includeComments: true`, and `maxCommentsPerVideo: 50` can produce up to 100 videos plus 5,000 comment rows. Turn `includeComments` on only when you want viewer reactions, and keep `maxCommentsPerVideo` modest.
- **Channel and playlist videos carry richer metrics than search rows.** When you scrape a channel or playlist, each video is enriched with real `viewCount`, `likeCount`, `category`, and `tags`. Plain keyword searches return the lighter fields the search index exposes — paste a channel URL when you need accurate counts.
- **Cap unlimited runs deliberately.** Setting `maxResults` to `0` collects everything — a large channel can hold thousands of videos, so only go unlimited when you truly want the full back-catalogue.
- **Use second-precision duration filters to isolate formats.** `maxDurationSeconds: 60` surfaces shorts; `minDurationSeconds: 1200` isolates long-form content — far more precise than rough minute buckets.

### Pricing

**From $4.00 per 1,000 videos** — undercuts the market for Dailymotion extraction while bundling channels, playlists, and optional comments. You pay per result collected, plus a small fixed per-run start fee. **No compute or time-based charges — you pay per result.**

You're charged per **video**, **channel**, and **playlist** result at the headline rate, plus a lower per-**comment** rate when you turn comments on. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost for video, channel, and playlist results at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.43 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.25 | $4.00 |
| 10,000 | $48.00 | $45.00 | $42.50 | $40.00 |
| 100,000 | $480.00 | $450.00 | $425.00 | $400.00 |

Comments are billed separately at a lower rate — **$0.60 / 1,000 (No discount) · $0.56 Bronze · $0.53 Silver · $0.50 Gold** — and the same discount tiers apply.

**Example costs (Gold):** 1,000 videos with comments off = **$4.00**. 1,000 videos plus 20 comments each (20,000 comments) = $4.00 + $10.00 = **$14.00**.

A "result" is any row in the output dataset — a video, channel, playlist, or comment. Platform fees (compute, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate media research, market analysis, and audience intelligence. Users are responsible for complying with applicable laws and Dailymotion's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data — such as commenter names — in line with applicable privacy regulations.

# Actor input Schema

## `queries` (type: `array`):

Add search terms (e.g. "breaking news") or paste Dailymotion links — a video, channel, or playlist URL. Each entry is processed on its own. Search terms return search results; URLs return that item and its contents.

## `searchType` (type: `string`):

When an entry is a plain search term, choose what kind of result to return. This is ignored when you paste a direct Dailymotion link.

## `maxResults` (type: `integer`):

Maximum number of results to collect for each search term, channel, or playlist. Set to 0 to collect everything (use with care — large channels can hold thousands of videos).

## `sortBy` (type: `string`):

Ordering for search results.

## `uploadDate` (type: `string`):

Only include videos uploaded within this time window.

## `minDurationSeconds` (type: `integer`):

Only include videos that are at least this many seconds long. Leave empty for no minimum.

## `maxDurationSeconds` (type: `integer`):

Only include videos that are at most this many seconds long. Leave empty for no maximum.

## `includeComments` (type: `boolean`):

When enabled, comments are collected for each video as separate rows. This adds results and increases cost. For channel and playlist runs, comments are pulled for every video collected, so total cost can far exceed Max results (e.g. 100 videos with up to 50 comments each can add up to 5,000 comment rows on top of the 100 videos). Off by default.

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

When comments are enabled, the maximum number of comments to collect per video. Set to 0 to collect all comments.

## Actor input object example

```json
{
  "queries": [
    "breaking news",
    "https://www.dailymotion.com/dailymotion"
  ],
  "searchType": "videos",
  "maxResults": 100,
  "sortBy": "relevance",
  "uploadDate": "any",
  "includeComments": false,
  "maxCommentsPerVideo": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

Compact table of every result with type, title/name, channel, views, and URL.

## `details` (type: `string`):

All collected fields per row, including descriptions, durations, dates, counts, and identifiers.

# 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 = {
    "queries": [
        "breaking news",
        "https://www.dailymotion.com/dailymotion"
    ],
    "maxResults": 100,
    "maxCommentsPerVideo": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/dailymotion-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 = {
    "queries": [
        "breaking news",
        "https://www.dailymotion.com/dailymotion",
    ],
    "maxResults": 100,
    "maxCommentsPerVideo": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/dailymotion-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 '{
  "queries": [
    "breaking news",
    "https://www.dailymotion.com/dailymotion"
  ],
  "maxResults": 100,
  "maxCommentsPerVideo": 50
}' |
apify call solidcode/dailymotion-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dailymotion Scraper",
        "description": "[💰 $4.00 / 1K] Extract Dailymotion videos, channels, and playlists by search term or URL — titles, views, likes, durations, upload dates, channel info, and optional comments.",
        "version": "1.0",
        "x-build-id": "Ans1BNydOCxkRd8E3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~dailymotion-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-dailymotion-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/solidcode~dailymotion-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-dailymotion-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/solidcode~dailymotion-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-dailymotion-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": {
                    "queries": {
                        "title": "Search terms or Dailymotion URLs",
                        "type": "array",
                        "description": "Add search terms (e.g. \"breaking news\") or paste Dailymotion links — a video, channel, or playlist URL. Each entry is processed on its own. Search terms return search results; URLs return that item and its contents.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Search for",
                        "enum": [
                            "videos",
                            "channels",
                            "playlists"
                        ],
                        "type": "string",
                        "description": "When an entry is a plain search term, choose what kind of result to return. This is ignored when you paste a direct Dailymotion link.",
                        "default": "videos"
                    },
                    "maxResults": {
                        "title": "Max results per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of results to collect for each search term, channel, or playlist. Set to 0 to collect everything (use with care — large channels can hold thousands of videos).",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "recent",
                            "views"
                        ],
                        "type": "string",
                        "description": "Ordering for search results.",
                        "default": "relevance"
                    },
                    "uploadDate": {
                        "title": "Uploaded within",
                        "enum": [
                            "any",
                            "today",
                            "week",
                            "month",
                            "year"
                        ],
                        "type": "string",
                        "description": "Only include videos uploaded within this time window.",
                        "default": "any"
                    },
                    "minDurationSeconds": {
                        "title": "Minimum video length (seconds)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include videos that are at least this many seconds long. Leave empty for no minimum."
                    },
                    "maxDurationSeconds": {
                        "title": "Maximum video length (seconds)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include videos that are at most this many seconds long. Leave empty for no maximum."
                    },
                    "includeComments": {
                        "title": "Also collect comments",
                        "type": "boolean",
                        "description": "When enabled, comments are collected for each video as separate rows. This adds results and increases cost. For channel and playlist runs, comments are pulled for every video collected, so total cost can far exceed Max results (e.g. 100 videos with up to 50 comments each can add up to 5,000 comment rows on top of the 100 videos). Off by default.",
                        "default": false
                    },
                    "maxCommentsPerVideo": {
                        "title": "Max comments per video",
                        "minimum": 0,
                        "type": "integer",
                        "description": "When comments are enabled, the maximum number of comments to collect per video. Set to 0 to collect all comments.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```