# YouTube Hashtag Search Scraper (`data_minds/youtube-hashtag-search-scraper`) Actor

Collect videos and Shorts posted under any YouTube hashtag. Get title, link, views, publish date, duration, description and channel. Choose videos, Shorts or both. No login or API key. Bulk input, auto proxy fallback. Export JSON, CSV or Excel.

- **URL**: https://apify.com/data_minds/youtube-hashtag-search-scraper.md
- **Developed by:** [Data Minds](https://apify.com/data_minds) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What is YouTube Hashtag Search Scraper?

**YouTube Hashtag Search Scraper** collects the videos and Shorts posted under any [YouTube](https://www.youtube.com) hashtag. Just enter hashtags or hashtag page URLs, choose videos, Shorts or both, and get one row per item with title, link, thumbnail, views, channel, publish date, duration and description. No YouTube account or API key needed, so you can start in minutes. **From $0.002 per result on the Gold plan ($2.00 per 1,000)**, plus platform usage. [🚀 Try it free](https://apify.com/data_minds/youtube-hashtag-search-scraper)

- **YouTube hashtag research:** see which videos and Shorts rank under a hashtag and how many views they have.
- **YouTube trend research:** compare view counts and publish dates across several hashtags to spot what is growing.
- **YouTube creator discovery:** list the channels that publish under a hashtag, with channel ID, title and handle, for YouTube influencer research.
- **YouTube competitor analysis:** check which brands and creators show up for the hashtags you care about.
- **YouTube content planning:** collect titles, descriptions and durations to plan your next video or Short.

Because it runs on Apify, you also get an API, scheduling, webhooks, integrations and export to JSON, CSV, Excel, XML or HTML.

#### What can YouTube Hashtag Search Scraper do?

- 🔎 **Scrape YouTube hashtag videos and Shorts:** one run can cover many hashtags, each collected separately.
- 🔗 **Accept hashtags in several forms:** `funny`, `#funny` or a full hashtag page link all work.
- 🎯 **Filter by content type:** collect regular videos, Shorts only, or both together.
- 📺 **Add channel data:** the YouTube channel handle, ID and title for every item when full details are on.
- 👀 **Return exact views and dates:** exact view count and exact UTC publish time with full details.
- 🔓 **Scrape YouTube without an API key:** no key or login is asked for.
- 🧾 **Collect YouTube video metadata:** titles, descriptions, thumbnails, durations, badges and view counts in one row.
- 🔢 **Set a limit per hashtag:** cap the items for each hashtag, or collect everything available.
- ⚡ **Save results as they are found:** each item is written to the dataset as soon as it is ready.

### What data can YouTube Hashtag Search Scraper extract?

Each dataset item is one video or Short. The Output tab shows four table views: overview, channel, views and timing, and descriptions.

| Field | What it contains |
|---|---|
| 🔖 `hashtag` | The hashtag the item was found under, lowercase and without #. |
| 🆔 `id` | The YouTube video or Short ID. |
| 🎬 `kind` | `video` or `short`. |
| 🔗 `url` | Link to the video or Short. |
| 📝 `title` | Title of the video or Short. |
| 📄 `description` | Full description text. |
| 🌄 `thumbnailUrl` | Largest available thumbnail. |
| 📺 `channel` | Object with `id`, `title`, `handle` and `thumbnailUrl` of the publishing channel. |
| 👀 `viewCount` | Number of views as a whole number. |
| 💬 `viewCountText` | View count as YouTube shows it, for example `1,500,295 views`. |
| 📅 `publishedAt` | Exact publish time in UTC (ISO 8601). |
| 🕒 `publishedTimeText` | Relative publish time as YouTube shows it, for example `1 month ago`. |
| 🕐 `durationSeconds` | Length in seconds. |
| ⌛ `durationText` | Length as `m:ss` or `h:mm:ss`. |
| 🏅 `badges` | Badges shown on the video, such as `New` or `4K`. A list, empty when there are none. |

> **Note:** Fields YouTube does not provide for an item are `null`. With `includeDetails` turned off, `description` and `publishedAt` stay empty. Shorts come with fewer fields in the hashtag list, so `channel`, `publishedAt` and the length fields are filled only when `includeDetails` is on.

#### What data can't YouTube Hashtag Search Scraper extract?

- Likes, comment counts and comments are not part of the output.
- Subtitles and transcripts are not included.
- Channel subscriber counts are not included.

For Shorts with likes, comments and subtitles, try [YouTube Shorts Scraper](https://apify.com/data_minds/youtube-shorts-scraper).

### How to scrape YouTube hashtag videos and Shorts

This Actor is built for an easy start, even if you have never extracted data from the web before.

1. [Create a free Apify account](https://console.apify.com/sign-up) with your email.
2. Open [YouTube Hashtag Search Scraper](https://apify.com/data_minds/youtube-hashtag-search-scraper) in the Apify Store.
3. Add one or more hashtags or hashtag page URLs to `urls`.
4. Choose `contentType` (all, videos or Shorts) and set `maxItemsPerKeyword`.
5. Leave `includeDetails` on for channel, description, exact date and exact views.
6. Click **Start** and watch items appear in the Output tab while the run is going.
7. Download your data in JSON, CSV, Excel, XML or HTML.

### How much does it cost to scrape YouTube?

This Actor uses pay-per-event pricing: you pay for each video or Short saved to the dataset, plus a small start fee for each run. Platform usage is billed in addition. The price per result drops as your Apify plan goes up.

| Apify plan | Price per result | Price per 1,000 results |
|---|---|---|
| Free | $0.003 | $3.00 |
| Bronze | $0.0027 | $2.70 |
| Silver | $0.0024 | $2.40 |
| Gold | $0.002 | $2.00 |

The default memory is 1024 MB, so each run is charged one start event of $0.00005. The account's pricing page also lists a default dataset item event of $0.00001, but the Actor's own code charges only the result event above. Check the [pricing page](https://apify.com/data_minds/youtube-hashtag-search-scraper/pricing) for the current list of events.

**Worked example:** collecting 1,000 videos and Shorts on the Gold plan costs 1,000 x $0.002 = $2.00 for results, plus the $0.00005 start event, plus platform usage.

**Free plan math:** the $5 monthly credit on the Free plan covers about 1,666 results at $0.003 each, before platform usage.

#### Is scraping YouTube hashtags free?

You can start without paying: the Free plan includes a $5 monthly credit, and the Free plan price above is charged against it. Beyond the credit, you pay per result. A small test run with `maxItemsPerKeyword` set to 10 shows the cost before you scale up.

### Input

The only required input is `urls`: one or more YouTube hashtags or hashtag page URLs. Everything else has a default. Here is an example that collects videos and Shorts for two hashtags:

```json
{
  "urls": ["funny", "https://www.youtube.com/hashtag/makeup"],
  "contentType": "all",
  "maxItemsPerKeyword": 10,
  "includeDetails": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

See the [input schema](https://apify.com/data_minds/youtube-hashtag-search-scraper/input-schema) for the full description of every field.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `urls` | array of strings | Yes | none | Hashtags with or without #, or full hashtag page URLs. Each one is collected separately. |
| `contentType` | string | No | `all` | `all` for videos and Shorts, `videos` for regular videos only, `shorts` for Shorts only. |
| `maxItemsPerKeyword` | integer | No | `10` | Stop after this many items for each hashtag. `0` collects everything available. Range 0 to 100000. |
| `includeDetails` | boolean | No | `true` | Adds description, channel, exact publish date and exact view count to every item. Turn off for a faster run with basic fields. |
| `proxyConfiguration` | object | No | `{ "useApifyProxy": true }` in the form | Optional proxy settings for the run. |

#### urls

Write one hashtag per line. The `#` is optional, and a hashtag page link is accepted. Letters are lowercased, spaces are removed and repeated hashtags are collected once.

- ✅ Good: `funny`
- ✅ Good: `#makeup`
- ✅ Good: `https://www.youtube.com/hashtag/makeup`
- ❌ Bad: `funny videos` (the space is removed, so it searches the single hashtag `funnyvideos`)
- ❌ Bad: a YouTube search results link or a channel link (these are not hashtags)

> **Warning:** With `contentType` set to `all` or `videos`, a hashtag that does not exist is reported as "hashtag not found" in the run summary. With `shorts`, it is reported as "no results for this hashtag and filter". Either way no items are saved.

#### maxItemsPerKeyword

This limit applies to each hashtag, not to the whole run, so two hashtags with a limit of 10 can save up to 20 items. The form default is 10. If you start the Actor through the API and leave the field out, the Actor collects up to 50 items per hashtag.

- ✅ Good: `10` for a first test run
- ✅ Good: `0` to collect everything available for each hashtag
- ❌ Bad: `-5` (negative numbers are rejected)

> **Warning:** With `0`, large hashtags can produce many results and a larger bill. Set a maximum cost per run in Apify to stay in control.

#### contentType

Use `all` to mix videos and Shorts, `videos` for regular videos only and `shorts` for Shorts only. Other values are rejected with an error message before the run starts.

### Output

Results are stored in the run's dataset, in the **Output** or **Storage** tab. View them as a table or JSON, pick the fields you need and download them as JSON, CSV, Excel, XML or HTML. That makes it a simple YouTube CSV export or YouTube JSON export for spreadsheets and dashboards. The tables are split into overview, channel, views and timing, and descriptions.

#### JSON example

Results for the input example above. A video:

```json
{
  "hashtag": "funny",
  "id": "aB3dE5fG7hI",
  "kind": "video",
  "url": "https://www.youtube.com/watch?v=aB3dE5fG7hI",
  "title": "Funny moments compilation",
  "description": "A short description with #funny #memes",
  "thumbnailUrl": "https://example.com/thumbnail-video.jpg",
  "channel": {
    "id": "UCexample0000000000000000",
    "title": "Example Channel",
    "handle": "ExampleChannel",
    "thumbnailUrl": "https://example.com/channel-picture.jpg"
  },
  "viewCount": 1500295,
  "viewCountText": "1,500,295 views",
  "publishedAt": "2026-09-11T11:53:15.000Z",
  "publishedTimeText": "1 month ago",
  "durationSeconds": 757,
  "durationText": "12:37",
  "badges": ["New"]
}
```

A Short, with full details turned on:

```json
{
  "hashtag": "funny",
  "id": "zY9xW8vU7tS",
  "kind": "short",
  "url": "https://www.youtube.com/shorts/zY9xW8vU7tS",
  "title": "Funny cat fail",
  "description": "Short description #funny #shorts",
  "thumbnailUrl": "https://example.com/thumbnail-short.jpg",
  "channel": {
    "id": "UCexample1111111111111111",
    "title": "Example Shorts Channel",
    "handle": "ExampleShorts",
    "thumbnailUrl": null
  },
  "viewCount": 2763524,
  "viewCountText": "2.7M views",
  "publishedAt": "2026-10-04T12:34:35.000Z",
  "publishedTimeText": null,
  "durationSeconds": 14,
  "durationText": "0:14",
  "badges": []
}
```

The run summary is saved in the key-value store under the key `RUN_SUMMARY`:

```json
{
  "totalSaved": 20,
  "hashtags": [
    { "input": "funny", "status": "ok", "returned": 10, "note": "" },
    { "input": "makeup", "status": "ok", "returned": 10, "note": "" }
  ],
  "notStarted": [],
  "requests": 41,
  "durationSeconds": 38.5
}
```

#### Notes and limitations

- Each hashtag gets a `status` in the run summary: `ok`, `empty` (nothing found), `blocked` or `error`, with a short `note`.
- Items are de-duplicated within a hashtag, so the same video is not saved twice for one hashtag.
- If the same video appears under two hashtags, it is saved once for each hashtag.
- If full details cannot be loaded for an item, the item is kept with its basic fields.
- Only items that are saved count toward your charges. The run stops cleanly when the maximum cost per run is reached.

### Tips and advanced usage

- Start with `maxItemsPerKeyword` set to 10 and check the output before a large run.
- Turn `includeDetails` off for a faster run when you only need titles, links, views as shown, thumbnails and channel names from the list.
- Run `shorts` and `videos` as separate runs if you want to compare the two formats for the same hashtags.
- Set up scheduled YouTube scraping on Apify to track a hashtag every day or week, and compare `viewCount` over time. It works as a YouTube hashtag tracker and for YouTube social media monitoring.
- Export YouTube hashtag videos to Excel or CSV to share the list with your team.
- Use it as a YouTube data extractor for dashboards, reports and AI workflows.

### Integrations and API

#### Can I use YouTube Hashtag Search Scraper as an API?

Yes. The [Apify API](https://docs.apify.com/api/v2) lets you start runs, schedule them and fetch results programmatically. Use the `apify-client` package for Node.js or for Python. Open the [API tab](https://apify.com/data_minds/youtube-hashtag-search-scraper/api) for ready-to-use code.

#### How to scrape YouTube hashtags with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("data_minds/youtube-hashtag-search-scraper").call(run_input={
    "urls": ["funny", "https://www.youtube.com/hashtag/makeup"],
    "contentType": "all",
    "maxItemsPerKeyword": 10,
    "includeDetails": True,
    "proxyConfiguration": {"useApifyProxy": True},
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["hashtag"], item["kind"], item["title"], item["viewCount"])
```

#### Can I integrate YouTube Hashtag Search Scraper with other apps?

Yes. Connect it with Make, Zapier, Google Sheets, Slack and other tools through Apify integrations. Use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger an action when a run finishes, and schedule runs to keep your hashtag data fresh.

#### Can I use YouTube Hashtag Search Scraper with AI agents (MCP)?

Yes. Connect the Actor to Claude and other AI assistants through the Apify MCP server. Open the [MCP tab](https://apify.com/data_minds/youtube-hashtag-search-scraper/api/mcp) for the setup steps.

### Other YouTube search scrapers

| Actor | What it does |
|---|---|
| 🔍 [YouTube Search API](https://apify.com/data_minds/youtube-search-api) | Search YouTube for videos, channels and playlists with enriched engagement, channel, and transcript data. |
| 📈 [YouTube Trending Shorts Scraper](https://apify.com/data_minds/youtube-trending-shorts-scraper) | Collect trending YouTube Shorts for any search, hashtag or topic, with views, likes, comments, channel, publish date and keywords. |
| 🎬 [YouTube Shorts Scraper](https://apify.com/data_minds/youtube-shorts-scraper) | Collects Shorts from any channel you list: views, likes, comments, hashtags, subtitles and full channel details. |

### FAQ

#### Is it legal to scrape YouTube hashtags?

Scraping publicly available data is generally considered legal, but you must respect personal data rules such as GDPR, copyright and YouTube's terms. Collect personal data only with a legitimate reason. This is not legal advice, so read [Apify's guide to web scraping legality](https://blog.apify.com/is-web-scraping-legal/) and consult a lawyer if unsure.

#### How does YouTube Hashtag Search Scraper work?

You give it hashtags, and it returns one row per video or Short found under each hashtag. With full details on, each row also carries the description, channel, exact publish date and exact view count. It saves every item as it goes and stops at your limit, at the end of the results, or at your spend limit.

#### Why scrape YouTube hashtag data?

Hashtag data shows what people publish and watch around a topic. Marketers use it for trend research and content planning, agencies for competitor analysis, and creators for hashtag research and finding other channels in their niche. A scheduled run turns this into a repeatable report in a spreadsheet or dashboard instead of manual checking.

#### Why am I getting fewer results than expected?

Usually the hashtag has fewer public items than your limit, the `contentType` filter excludes some of them, or the hashtag was not found. Check the `status` and `note` for each hashtag in `RUN_SUMMARY`. Then raise `maxItemsPerKeyword` or set it to 0, and run again with the right spelling.

#### How many videos can I get per hashtag?

Set `maxItemsPerKeyword` to the number you want for each hashtag, from 1 up to 100000, or to 0 to collect everything available. The real total depends on how many public videos and Shorts the hashtag has. Start with 10 as a test, then raise the limit once the output looks right.

#### Can I scrape only YouTube Shorts for a hashtag?

Yes. Set `contentType` to `shorts` and add your hashtags to `urls`. The run then returns only Shorts, one row per Short. Keep `includeDetails` on if you also want the channel, description, exact publish date and exact view count, because the basic list holds fewer fields for Shorts.

#### Does scraping YouTube hashtags need a login or API key?

No. You only need an Apify account. The Actor asks for no YouTube login, cookies or API key, and it collects only public information that anyone can see for a hashtag. Enter your hashtags, press Start, and the results arrive in the dataset, ready to export or send through the API.

#### YouTube Hashtag Search Scraper not working?

First open the run log and the `RUN_SUMMARY` record to see the status and note for each hashtag. Check the hashtag spelling and try a smaller `maxItemsPerKeyword`. If the problem remains, report it on the [Issues tab](https://apify.com/data_minds/youtube-hashtag-search-scraper/issues/open) with your run link so we can look at it.

### Support and feedback

Found a bug or have a feature request? Please create an issue on the [Issues tab](https://apify.com/data_minds/youtube-hashtag-search-scraper/issues/open).

Need a **custom solution** or more data? Contact us at hello.dataminds@gmail.com.

Built and maintained by the [data_minds team](https://apify.com/data_minds) on Apify.

This Actor is an independent tool and is not affiliated with or endorsed by YouTube or Google. It collects publicly available data, and you are responsible for using it in line with applicable laws and the platform's terms.

# Changelog

This Actor's version history is a separate document: https://apify.com/data_minds/youtube-hashtag-search-scraper/changelog.md

# Actor input Schema

## `urls` (type: `array`):

One hashtag per line, with or without #, or a full hashtag page URL such as https://www.youtube.com/hashtag/funny. Add as many as you like; each one is collected separately.

## `contentType` (type: `string`):

All returns regular videos and Shorts mixed together. Videos returns only regular videos. Shorts returns only Shorts.

## `maxItemsPerKeyword` (type: `integer`):

Stop after this many items for each hashtag. Use 0 to collect everything available.

## `includeDetails` (type: `boolean`):

Adds the description, channel, exact publish date and exact view count to every item. Turn off for a faster run with basic fields only.

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

Optional proxy settings for the run.

## Actor input object example

```json
{
  "urls": [
    "funny",
    "https://www.youtube.com/hashtag/makeup"
  ],
  "contentType": "all",
  "maxItemsPerKeyword": 10,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All items, overview table.

## `channel` (type: `string`):

Channel details per item.

## `engagement` (type: `string`):

Views, publish time, length and badges per item.

## `description` (type: `string`):

Full description text per item.

## `summary` (type: `string`):

Totals and status for each hashtag.

# 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 = {
    "urls": [
        "funny",
        "https://www.youtube.com/hashtag/makeup"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_minds/youtube-hashtag-search-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 = {
    "urls": [
        "funny",
        "https://www.youtube.com/hashtag/makeup",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("data_minds/youtube-hashtag-search-scraper").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 '{
  "urls": [
    "funny",
    "https://www.youtube.com/hashtag/makeup"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call data_minds/youtube-hashtag-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_minds/youtube-hashtag-search-scraper"
        }
    }
}
```

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/hQy185N5QXhOa3Ws3/builds/XaKauczUzbVofo9lW/openapi.json