# **Youtube Search Prompt** (`dtrungtin/youtube-search-prompt`) Actor

Scrape Youtube videos from a **plain-English prompt** — no URL building required. Describe what you're looking for (for example, *"gaming laptop under 1000 USD with RTX 4060"*), and the Actor uses AI to turn your prompt into multiple targeted Youtube search URLs, scrapes the matching videos

- **URL**: https://apify.com/dtrungtin/youtube-search-prompt.md
- **Developed by:** [Tin](https://apify.com/dtrungtin) (community)
- **Categories:** AI, Videos
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 does YouTube Search Prompt do?

**YouTube Search Prompt** lets you scrape [YouTube](https://www.youtube.com/) videos from a **plain-English prompt** — no URL building required. Describe what you're looking for (for example, *"popular videos about home espresso brewing"*), and the Actor uses AI to turn your prompt into multiple targeted YouTube search URLs, scrapes the matching videos, and stores them as a structured dataset.

Under the hood, it chains two Actors together:

1. [AI Scraper Input Generator](https://apify.com/dtrungtin/ai-scraper-input-generator) converts your prompt into YouTube search URLs.
2. [YouTube Scraper](https://apify.com/dtrungtin/youtube-scraper) crawls those URLs and extracts the videos with full metadata — titles, view counts, likes, channel info, descriptions, and more.

Because it runs on the Apify platform, you get **API access, scheduling, monitoring, and integrations** (Make, Zapier, webhooks, Google Drive, and more) out of the box.

### Why use YouTube Search Prompt?

- **No manual URL construction** — describe your intent in natural language, and the AI handles YouTube's search URL format and query variations.
- **Better coverage** — one prompt becomes several targeted search URL variations, surfacing videos a single query would miss.
- **Trend research made simple** — schedule a daily run of "AI coding assistant reviews" and watch how coverage of a topic evolves.
- **Channel and competitor analysis** — compare view counts, subscribers, and engagement across every channel covering your niche.
- **Automation-ready** — predictable JSON output that plugs straight into data pipelines, dashboards, and NLP workflows — without YouTube Data API quotas.

### How to use YouTube Search Prompt

1. Open the Actor in Apify Console.
2. In the **Input** tab, enter your search prompt in plain English.
3. Optionally adjust **Max items** to limit how many videos are scraped per generated URL.
4. Set the Actor's memory to **128 MB or less** in the run options (the Actor enforces this limit, since the heavy lifting happens in the chained Actors).
5. Click **Start** and wait for the run to finish.
6. Open the **Output** tab or the dataset API URL to view and export your results.

### Input

Set the input in the Actor's Input tab. Only the prompt is required.

```json
{
    "prompt": "popular videos about home espresso brewing",
    "maxItems": 50
}
````

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| prompt | string | Yes | Plain-English description of what to find on YouTube. Topics, products, and questions all work — be specific for best results. |
| maxItems | integer | No | Maximum number of videos to scrape per generated URL (default 10, maximum 500). |

Note: `maxItems` applies **per generated URL**, so with the default `numberOfUrls` of 3 a run can return up to 3× `maxItems` videos.

### Output

Each scraped YouTube video is stored as one item in the default dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Example dataset item (shortened):

```json
{
    "title": "Stromae - Santé (Live From The Tonight Show Starring Jimmy Fallon)",
    "id": "CW7gfrTlr0Y",
    "url": "https://www.youtube.com/watch?v=CW7gfrTlr0Y",
    "thumbnailUrl": "https://i.ytimg.com/vi/CW7gfrTlr0Y/maxresdefault.jpg",
    "viewCount": 35582192,
    "date": "2021-12-21",
    "likes": 512238,
    "channelName": "StromaeVEVO",
    "channelUrl": "http://www.youtube.com/@StromaeVEVO",
    "numberOfSubscribers": 6930000,
    "duration": "00:03:17",
    "commentsCount": 14,
    "text": "Stromae - Santé (Live From The Tonight Show Starring Jimmy Fallon on NBC)...",
    "subtitles": ["en", "fr"],
    "isMonetized": true
}
```

### Data table

| Field | Type | Description |
| --- | --- | --- |
| title | string | Video title |
| id | string | YouTube video ID |
| url | string | Direct link to the video |
| thumbnailUrl | string | Video thumbnail image URL |
| viewCount | number | Total view count |
| date | string | Upload date |
| likes | number | Like count |
| channelName / channelUrl | string | Channel name and URL |
| numberOfSubscribers | number | Channel subscriber count |
| duration | string | Video length (HH:MM:SS) |
| text | string | Video description |
| subtitles | array | Available caption language codes |
| isMonetized | boolean | Whether the video shows ads |

Exact fields may vary slightly by video, since not all YouTube videos expose the same attributes.

### How much does it cost to scrape YouTube with a prompt?

A run consists of three parts: this orchestrator Actor (very light — it runs at 128 MB and mostly waits), one short AI Scraper Input Generator run, and the YouTube scraper run whose cost scales with the number of videos collected. For small runs (tens of videos) the total cost is typically well under a dollar. Use **Max items** and **Number of URLs** to cap the scraping cost of each run. If you are on the Apify free tier, start with small values to see actual consumption before scaling up.

### Tips

- **Be specific in your prompt.** "Beginner espresso machine reviews under $500" produces much better search URLs than "coffee".
- **Start small.** Run with a low `maxItems` first to check that the generated URLs match your intent, then scale up (maximum 500 per URL).
- **Schedule it.** Add the Actor to a Schedule to monitor a topic or niche daily, and connect a webhook or integration to act on the results.
- **Keep memory at 128 MB.** The Actor intentionally refuses to run with more, because the chained Actors do the actual work — extra memory would only add cost.

### FAQ, disclaimers, and support

**Is it legal to scrape YouTube?** This Actor extracts publicly available video data. You are responsible for reviewing and complying with YouTube's Terms of Service and applicable laws (including data protection regulations) before using the results, especially in automated or commercial workflows. Do not collect or misuse personal data.

**Why did my run fail with a memory error?** This Actor requires memory of 128 MB or less. Lower the memory setting in the run options and start it again.

**Why are there no results?** If the AI could not generate valid search URLs from your prompt, the run fails with a clear error — rephrase the prompt with more specific topic terms and try again.

Found a bug or need a custom feature? Open an issue in the Actor's **Issues** tab — custom solutions and tailored versions are available on request.

# Actor input Schema

## `prompt` (type: `string`):

Describe what you want to search for on Youtube. The Actor will generate search URLs from this prompt and scrape the results.

## `maxItems` (type: `integer`):

Limit of video pages to be scraped

## Actor input object example

```json
{
  "prompt": "gaming laptop under 1000 USD with RTX 4060",
  "maxItems": 1
}
```

# 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 = {
    "prompt": "gaming laptop under 1000 USD with RTX 4060",
    "maxItems": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("dtrungtin/youtube-search-prompt").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 = {
    "prompt": "gaming laptop under 1000 USD with RTX 4060",
    "maxItems": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("dtrungtin/youtube-search-prompt").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 '{
  "prompt": "gaming laptop under 1000 USD with RTX 4060",
  "maxItems": 1
}' |
apify call dtrungtin/youtube-search-prompt --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "**Youtube Search Prompt**",
        "description": "Scrape Youtube videos from a **plain-English prompt** — no URL building required. Describe what you're looking for (for example, *\"gaming laptop under 1000 USD with RTX 4060\"*), and the Actor uses AI to turn your prompt into multiple targeted Youtube search URLs, scrapes the matching videos",
        "version": "0.0",
        "x-build-id": "M8pk2IdhKFWhItuyT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dtrungtin~youtube-search-prompt/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dtrungtin-youtube-search-prompt",
                "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/dtrungtin~youtube-search-prompt/runs": {
            "post": {
                "operationId": "runs-sync-dtrungtin-youtube-search-prompt",
                "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/dtrungtin~youtube-search-prompt/run-sync": {
            "post": {
                "operationId": "run-sync-dtrungtin-youtube-search-prompt",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "prompt"
                ],
                "properties": {
                    "prompt": {
                        "title": "Prompt Keywords",
                        "type": "string",
                        "description": "Describe what you want to search for on Youtube. The Actor will generate search URLs from this prompt and scrape the results.",
                        "default": "gaming laptop under 1000 USD with RTX 4060"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Limit of video pages to be scraped",
                        "default": 10
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
