# Youtube Tags or Hashtags Scraper (`alpha-scraper/youtube-tags-or-hashtags-scraper`) Actor Extract YouTube tags and hashtags from public videos with the Youtube Tags or Hashtags Scraper. Submit one or multiple YouTube video URLs to collect structured tags, hashtags, thumbnail URLs, and video links for SEO research, content analysis, and dataset creation. - **URL**: https://apify.com/alpha-scraper/youtube-tags-or-hashtags-scraper.md - **Developed by:** [Alpha Scraper](https://apify.com/alpha-scraper) (community) - **Categories:** Social media, Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 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 ### Youtube Tags or Hashtags Scraper The **Youtube Tags or Hashtags Scraper** extracts YouTube video tags and hashtags from public YouTube video pages using one or multiple video URLs. It is designed for users who need structured metadata for content research, SEO analysis, competitive research, dataset creation, or other data workflows. Provide YouTube video URLs through the `startUrls` input, run the Actor, and receive one structured result for each successfully processed video. The returned data includes the video URL, thumbnail URL, YouTube tags, and hashtags detected in the video's title and description. The Actor accepts URLs entered through the request-list style input, including standard `youtube.com/watch` URLs and supported YouTube URL formats such as `youtu.be` links. ### What Is a Youtube Tags or Hashtags Scraper? A **Youtube Tags or Hashtags Scraper** is a data extraction tool focused on collecting metadata associated with public YouTube videos. Instead of manually opening videos and copying tags or hashtags, users can submit a list of video URLs and collect the available information in a structured dataset. This Actor extracts two related types of metadata: - **YouTube tags** returned as tags associated with the video. - **YouTube hashtags** detected from the video's title and description. - **Thumbnail information** through the available thumbnail URL. - **Original video URL** for easy identification and traceability. The hashtags are identified from the text available in the video title and description. Duplicate hashtags are removed before they are returned. ### Key Features | **Feature** | **Description** | **User Benefit** | | -------------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------- | | Multiple YouTube URLs | Process one or more video URLs through `startUrls` | Collect metadata from several videos in one run | | Video tag extraction | Returns the tags associated with each processed video | Useful for keyword and content research | | Hashtag extraction | Detects hashtags in video titles and descriptions | Helps analyze hashtag usage and topical themes | | Array and text fields | Tags and hashtags are provided in both array and text forms | Convenient for analysis and downstream processing | | Thumbnail URL | Returns an available thumbnail URL | Makes it easier to associate visual assets with results | | Structured dataset results | Each successful video produces a separate structured output item | Simplifies filtering, analysis, and dataset creation | | Public video workflow | Designed for public YouTube video URLs | Suitable for research based on publicly available video pages | | Cookie-free operation | The Actor description specifies operation without cookies | Reduces the need for users to provide browser cookies | ### What Data Can You Extract? The **Youtube Tags or Hashtags Scraper** returns a compact set of video metadata centered on tags and hashtags. **Video identification** Each result includes the YouTube URL supplied for processing. This allows users to connect extracted metadata with the original source video. **Thumbnail information** The Actor returns a `thumbnailUrl` value when thumbnail information is available. When multiple thumbnail resolutions are available, it selects the highest available thumbnail resolution that includes a height value. **YouTube tags** The `tagsArray` field contains the tags returned for the video. The Actor also creates `tagsText`, which joins the available tags into a comma-separated string. **YouTube hashtags** The `hashtagsArray` field contains hashtags detected in the video's title and description. The Actor removes duplicates and sorts the resulting values. The `hashtagsText` field provides the hashtags as a space-separated string. ### Why Use This Actor? Manual collection of video tags and hashtags becomes repetitive when working with many YouTube videos. This Actor provides a simple URL-based workflow for collecting the same categories of information in a structured form. It can be useful when you need to: - Analyze keyword and hashtag patterns across selected videos. - Build datasets for YouTube content research. - Compare metadata across a group of public videos. - Study how creators use tags and hashtags around specific topics. - Prepare structured metadata for further analysis or reporting. Because the workflow is URL-based, users can select the exact videos they want to investigate rather than relying on a general keyword search. ### Benefits The Actor provides several practical benefits for metadata collection. **Automation** Instead of opening each video and manually recording tags and hashtags, users can submit multiple URLs and process them within one Actor run. **Structured results** Tags and hashtags are returned as arrays as well as text fields. This makes the resulting dataset easier to inspect and process in different workflows. **Research-focused extraction** The extracted fields are suitable for content research, topic discovery, keyword analysis, and comparative metadata studies. **Simple input model** The required input is a `startUrls` list containing YouTube video URLs. There are no additional configuration fields in the supplied input schema. **Duplicate hashtag handling** Repeated hashtags detected in the title and description are consolidated into a single hashtag entry. ### How to Use the Youtube Tags or Hashtags Scraper Using the Actor requires only a list of YouTube video URLs. 1. Open the Actor and locate the **Start URLs** input. 2. Add one or more public YouTube video URLs. 3. Start the Actor. 4. Review the structured results in the dataset. 5. Use the returned tags, hashtags, thumbnail URLs, and video URLs in your research or data workflow. For initial testing, use a small number of video URLs so you can confirm that the returned fields match your intended workflow before processing a larger URL list. ### Input The Actor has one required input field: `startUrls`. | **Field** | **Type** | **Required** | **Description** | | ----------- | -------- | ------------ | ------------------------------------------------ | | `startUrls` | Array | Yes | One or more YouTube video URL entries to process | The input is configured with a request-list style editor. Each list entry can contain a `url` value. The implementation also accepts string values, although the interface is designed around URL objects. The supplied `actor.json` does not define a numeric maximum for the number of URLs in `startUrls`, so no additional URL-count limit is documented here. ### Input Example ```json { "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }, { "url": "https://youtu.be/9bZkp7q19f0" } ] } ``` Use actual public YouTube video URLs when running the Actor. Avoid adding unsupported fields because they are not part of the documented input schema. ### Output Each successfully processed video produces one structured dataset item. The output focuses on video identification, thumbnail information, tags, and hashtags. Tags come from the video's available tag metadata, while hashtags are detected from the title and description. | **Field** | **Description** | | ----------------- | ----------------------------------------------------------- | | `youtubeVideoUrl` | The YouTube video URL processed by the Actor | | `thumbnailUrl` | Available thumbnail URL selected for the processed video | | `tagsArray` | Array of tags returned for the video | | `tagsText` | Tags joined into a comma-separated text string | | `hashtagsArray` | Unique hashtags detected in the video title and description | | `hashtagsText` | Hashtags joined into a space-separated text string | A video that cannot be processed successfully is not added as a successful output item. The Actor continues through the supplied URL list rather than requiring every submitted URL to produce a result. ### Output Example ```json { "youtubeVideoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "thumbnailUrl": "https://example.com/thumbnail.jpg", "tagsArray": [ "music", "official video", "pop" ], "tagsText": "music, official video, pop", "hashtagsArray": [ "#Music", "#OfficialVideo", "#Pop" ], "hashtagsText": "#Music #OfficialVideo #Pop" } ``` The example values above illustrate the output structure. Actual tags, hashtags, and thumbnail URLs depend on the processed video. ### Use Cases The **Youtube Tags or Hashtags Scraper** can support several research and data-collection workflows. **YouTube SEO research** Collect tags and hashtags from selected public videos to study keyword and topic patterns used by creators. **Content research** Researchers can compare metadata across videos covering similar subjects and identify recurring terminology. **Competitive research** Marketing and content teams can examine metadata from selected competitor or industry videos to understand how publicly visible video metadata is organized. **Dataset creation** Create structured video metadata datasets for further analysis, reporting, categorization, or internal research. **Hashtag analysis** Collect hashtags appearing in video titles and descriptions to investigate topical relationships and recurring hashtag usage. **Content planning** Writers and creators can use collected metadata as research material when studying how existing videos describe similar topics. ### Advantages The Actor combines several related metadata fields into a single dataset row, making it useful for workflows that need both tag and hashtag information. It also provides array and text versions of tags and hashtags. Arrays are useful when individual values need to be filtered or analyzed, while text fields can be more convenient for quick review or downstream text processing. The URL-based workflow also keeps the target set explicit: users decide which public YouTube videos should be analyzed by supplying their URLs. ### Limitations The Actor is focused specifically on public YouTube video URLs supplied through `startUrls`. It is not documented as a general YouTube search scraper, channel scraper, playlist scraper, or comment scraper. Hashtags are extracted from the video **title and description** using hashtag matching. They are not described as coming from a separate hashtag search index. Output availability can vary between videos. For example, a video may have no tags, no detectable hashtags, or unavailable thumbnail information. In those cases, corresponding fields can be empty. The supplied implementation does not define a custom maximum URL count in `actor.json`, but very large input lists may still require appropriate run planning and validation. ### Pros and Cons | **Pros** | **Cons** | | ---------------------------------- | --------------------------------------------------------------------------- | | Processes multiple video URLs | Focused on video URLs rather than general YouTube discovery | | Returns tags and hashtags together | Hashtags are detected specifically from title and description text | | Provides array and text formats | Some videos may not provide all metadata | | Includes thumbnail URL information | No separate input options for advanced filtering | | Simple required input structure | Does not document broader YouTube data such as comments or channel datasets | ### Comparison With Alternative Approaches | **Capability** | **This Actor** | **Manual / Typical Alternative** | | ------------------------------------ | ---------------------------------------------- | ------------------------------------------------- | | Process multiple selected video URLs | Supported through `startUrls` | Often requires opening videos individually | | Structured tags | Returned as `tagsArray` and `tagsText` | May require manual copying and formatting | | Structured hashtags | Returned as `hashtagsArray` and `hashtagsText` | Usually collected manually from visible text | | Thumbnail URL | Returned when available | May require separate manual collection | | Duplicate hashtag handling | Duplicate detected hashtags are consolidated | Manual cleanup may be required | | Dataset-oriented workflow | Output is pushed as structured dataset records | Manual research often needs additional formatting | This comparison describes workflow differences rather than guaranteeing that every manual or alternative approach behaves in exactly the same way. ### Best Practices For reliable and useful results: - Start with a small group of public YouTube video URLs and review the dataset. - Use valid video URLs and keep the `startUrls` structure consistent. - Check both array and text fields to determine which format best suits your workflow. - Treat empty tag or hashtag fields as valid possible outcomes rather than assuming every video contains metadata. - Validate important extracted information before using it in business-critical research or analysis. - Keep the original `youtubeVideoUrl` alongside extracted metadata so results remain easy to trace back to their source. ### Troubleshooting **Invalid or unsuitable input** Check that each entry in `startUrls` contains a valid YouTube video URL. Remove blank entries or malformed values before starting the run. **No result for a video** A submitted video may fail to produce information. Review the URL and confirm that the target is a public YouTube video page. The Actor skips inputs for which usable video information is not obtained. **Empty tags** Some videos may not return any tags. In this case, `tagsArray` can be empty and `tagsText` can contain an empty string. **No hashtags** Hashtags are detected from the title and description. A video without matching hashtag text can therefore produce an empty `hashtagsArray` and `hashtagsText`. **Missing thumbnail information** Thumbnail availability can differ by video. The Actor returns an available thumbnail URL when it can obtain one. **Partial results** When processing multiple URLs, some videos may succeed while others do not. Review the dataset against the original URL list when completeness is important. ### Frequently Asked Questions **What does the Youtube Tags or Hashtags Scraper do?** The Youtube Tags or Hashtags Scraper processes supplied public YouTube video URLs and returns video tags, hashtags, thumbnail information, and the original video URL in structured records. **What input does the Actor require?** It requires the `startUrls` array. Each entry should provide a YouTube video URL. **Can I process multiple YouTube videos?** Yes. `startUrls` is an array, so multiple video URLs can be submitted in the same run. **Where are the hashtags collected from?** The Actor detects hashtags in the video's title and description. Detected duplicates are removed before the results are returned. **How are YouTube tags returned?** Tags are available in `tagsArray` for individual values and `tagsText` as a comma-separated string. **How are hashtags returned?** Hashtags are provided through `hashtagsArray` and `hashtagsText`. The array contains unique, sorted hashtag values detected from the title and description. **Does the Youtube Tags or Hashtags Scraper return thumbnails?** Yes. The `thumbnailUrl` field contains an available thumbnail URL when thumbnail information is obtained. **What happens when a video has no tags or hashtags?** The related fields can be empty. The presence of an empty field does not necessarily indicate an input problem. **Can this Actor search YouTube by keyword?** The supplied input schema is based on video URLs. It is not documented as a keyword-based YouTube search scraper. **Is this Actor useful for automation?** Yes. Its URL-list input and structured dataset output make it suitable for repeatable research, metadata collection, and data-processing workflows where the target videos are already known. ### NLP Keywords - YouTube video metadata - YouTube tags - YouTube hashtags - video tag extraction - hashtag extraction - YouTube video scraper - public YouTube videos - video metadata scraper - YouTube SEO data - video keyword research - YouTube content research - structured video data - YouTube dataset creation - video title analysis - video description analysis - hashtag metadata - tag metadata - YouTube thumbnail URL - video metadata collection - YouTube research data ### Related Keywords - YouTube tags scraper - YouTube hashtag scraper - YouTube tags extractor - YouTube hashtags extractor - scrape YouTube video tags - scrape YouTube hashtags - extract YouTube video metadata - YouTube video tag extractor - YouTube video hashtag extractor - public YouTube video scraper - YouTube metadata extraction - YouTube keyword metadata - YouTube SEO tags research - YouTube hashtag research tool - YouTube video metadata extractor - YouTube video data collection - collect YouTube tags - collect YouTube hashtags - YouTube video research scraper - YouTube metadata dataset ### Final Overview The **Youtube Tags or Hashtags Scraper** provides a focused way to collect tag and hashtag metadata from selected public YouTube videos. Users submit one or more video URLs, and the Actor returns structured records containing the source URL, thumbnail URL, tags, and hashtags. Its straightforward input structure and dataset-oriented output make it suitable for YouTube SEO research, content analysis, metadata collection, competitive research, and structured dataset creation. Because the Actor documents a focused set of outputs, users can quickly understand what information will be collected and incorporate those results into their existing research workflow. **Contact me:** # Actor input Schema ## `startUrls` (type: `array`): List of one or more YouTube video URLs ## Actor input object example ```json { "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }, { "url": "https://youtu.be/9bZkp7q19f0" } ] } ``` # Actor output Schema ## `dataset` (type: `string`): No description # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }, { "url": "https://youtu.be/9bZkp7q19f0" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("alpha-scraper/youtube-tags-or-hashtags-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }, { "url": "https://youtu.be/9bZkp7q19f0" }, ] } # Run the Actor and wait for it to finish run = client.actor("alpha-scraper/youtube-tags-or-hashtags-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 '{ "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }, { "url": "https://youtu.be/9bZkp7q19f0" } ] }' | apify call alpha-scraper/youtube-tags-or-hashtags-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,alpha-scraper/youtube-tags-or-hashtags-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 ` 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/O1FU99ID2ccR5wcS8/builds/nU9V60SwuOK7rtNNf/openapi.json