# YouTube Bulk Keyword Search (`gocreative.ai/youtube-search-bulk-keyword`) Actor

Run a whole keyword list through YouTube search in one run. Returns videos with view counts, channel, duration and publish date — one row per video, tagged with its keyword.

- **URL**: https://apify.com/gocreative.ai/youtube-search-bulk-keyword.md
- **Developed by:** [GoCreative AI](https://apify.com/gocreative.ai) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 video results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Bulk Keyword Search

Run an entire keyword list through YouTube search in a single run. You get one clean row per
video — title, URL, channel, view count, duration, publish date — and every row is tagged with
the keyword that produced it, so a 200-keyword list comes back as one sortable table instead of
200 separate exports.

No API key. No YouTube Data API quota. No browser automation, so runs are fast and cheap.

### What you get

| Field | Example |
|---|---|
| `query` | `best espresso machine` |
| `title` | `Python Full Course for free 🐍` |
| `url` | `https://www.youtube.com/watch?v=ix9cRaBkVe0` |
| `video_id` | `ix9cRaBkVe0` |
| `channel_name` | `Bro Code` |
| `channel_handle` / `channel_id` / `channel_url` | `@BroCodez` · `UC4SVo0Ue36XCfOyb5Lh1viQ` |
| `view_count` | `11477738` |
| `view_count_text` | `11,477,738 views` |
| `duration_text` | `12:00:00` |
| `published_text` | `1 year ago` |
| `thumbnail` | `https://i.ytimg.com/vi/ix9cRaBkVe0/hq720.jpg` |
| `fetched_at` | `2026-08-15T19:44:02+00:00` |

`view_count` is a real integer, so you can sort and filter it directly in the dataset view or in
a spreadsheet — no parsing `1.2M` strings by hand.

### Every YouTube search filter, applied to your whole keyword list

The filters below are YouTube's own — the same ones behind the *Filters* button on the results
page — encoded into the request rather than applied after the fact. So `Uploaded within: today`
really asks YouTube for today's videos instead of fetching the default ranking and throwing most
of it away, and you get a full page of matches per keyword instead of the handful that survive a
post-filter.

### Input

```json
{
  "queries": ["best espresso machine", "ai agents", "cold brew at home"],
  "maxResultsPerQuery": 20,
  "sortBy": "views",
  "uploadedWithin": "month",
  "duration": "long",
  "hasSubtitles": true,
  "minViews": 10000
}
```

| Option | Default | Notes |
|---|---|---|
| `queries` | *(required)* | One search per keyword. Paste your whole list. |
| `maxResultsPerQuery` | `20` | 1–100 videos per keyword. |
| `sortBy` | `relevance` | `relevance`, `date`, `views` or `rating`. |
| `uploadedWithin` | *(any)* | `hour`, `today`, `week`, `month` or `year`. |
| `duration` | *(any)* | `short` (<4 min), `medium` (4–20), `long` (>20). |
| `hdOnly` | `false` | HD videos only. |
| `hasSubtitles` | `false` | Only videos carrying a subtitle track. |
| `creativeCommons` | `false` | Only Creative Commons licensed videos you can reuse. |
| `minViews` | `0` | Drops low-view videos after fetching. |

### What people use it for

- **Content research** — find which videos already rank for the keywords you plan to target, and
  how many views they pulled.
- **Competitor tracking** — run your category's keyword list weekly and diff the channels that
  keep surfacing.
- **Creator sourcing** — filter by `minViews` to surface only channels with proven reach for a
  given topic.
- **Trend sizing** — total `view_count` per keyword gives a fast demand proxy across a topic list.
- **Finding fresh content fast** — `uploadedWithin: today` across a keyword list surfaces what
  went up in the last few hours, which is where newsjacking and trend-riding start.

### Export

Results land in a standard Apify dataset: download as CSV, JSON, Excel or XML, or pull them from
the API. The default table view shows keyword, title, channel, views, duration, publish date and
URL.

### Notes

- Results reflect YouTube's own relevance ranking for a signed-out viewer, so they match what a
  fresh visitor sees rather than a personalized feed.
- Keywords that return nothing are logged as warnings and skipped; the run still completes with
  everything else.
- Transcripts are not part of this Actor. YouTube gates caption fetching behind a proof-of-origin
  token, and this Actor deliberately does not ship a workaround.

# Actor input Schema

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

One YouTube search per keyword. Paste a whole keyword list — the Actor runs them all in a single run and tags every result row with the keyword it came from.

## `maxResultsPerQuery` (type: `integer`):

How many videos to return for each keyword (1-100). YouTube ranks them by relevance, so the first 20 cover most use cases.

## `minViews` (type: `integer`):

Drop videos below this view count. Set 0 to keep everything. Useful for filtering a keyword list down to proven-demand content only.

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

YouTube's own search ordering. Relevance is what a visitor sees by default.

## `uploadedWithin` (type: `string`):

Only return videos published inside this window. Leave as Any time for no date limit.

## `duration` (type: `string`):

Filter by video length, using YouTube's own bands.

## `hdOnly` (type: `boolean`):

Only return videos available in HD.

## `hasSubtitles` (type: `boolean`):

Only return videos that carry a subtitle track. Useful for finding captioned content.

## `creativeCommons` (type: `boolean`):

Only return videos licensed Creative Commons — the ones you can legally reuse.

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

YouTube rate-limits cloud IPs, so runs go through Apify Proxy by default. Leave as-is unless you have a reason to change it.

## Actor input object example

```json
{
  "queries": [
    "best espresso machine",
    "ai agents"
  ],
  "maxResultsPerQuery": 20,
  "minViews": 0,
  "sortBy": "relevance",
  "uploadedWithin": "",
  "duration": "",
  "hdOnly": false,
  "hasSubtitles": false,
  "creativeCommons": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

# 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": [
        "best espresso machine",
        "ai agents"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("gocreative.ai/youtube-search-bulk-keyword").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": [
        "best espresso machine",
        "ai agents",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("gocreative.ai/youtube-search-bulk-keyword").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "best espresso machine",
    "ai agents"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}' |
apify call gocreative.ai/youtube-search-bulk-keyword --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gocreative.ai/youtube-search-bulk-keyword"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RxJIvtlyLqM3PjPnp/builds/px8WA5dMCKAL9EQK7/openapi.json