Pricing

from $1.00 / 1,000 shorts

Try for free

Go to Apify Store

YouTube Shorts Scraper — Views, Music & Hashtags, No Login

Try for free

Scrape YouTube Shorts from channels, Shorts searches, #hashtags or URLs: views, likes, comment count, publish date, duration, channel and subscribers, hashtags, the song used and thumbnail. Newest, popular or oldest first, newer-than date. From $1.00 per 1,000 Shorts. No login, no API key.

Pricing

from $1.00 / 1,000 shorts

Rating

0.0

(0)

Developer

Yugenox Corp

Actor stats

Bookmarked

Total users

Monthly active users

4 days ago

Last modified

Categories

Videos

Social media

Marketing

You can access the YouTube Shorts Scraper — Views, Music & Hashtags, No Login programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.1",
    "x-build-id": "9HmSdtBqYygyYzbQC"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/yugenox~youtube-shorts-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-yugenox-youtube-shorts-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/yugenox~youtube-shorts-scraper/runs": {
      "post": {
        "operationId": "runs-sync-yugenox-youtube-shorts-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/yugenox~youtube-shorts-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-yugenox-youtube-shorts-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": {
          "channels": {
            "title": "📺 Channels",
            "type": "array",
            "description": "Channels whose Shorts tab to read: a YouTube channel link (https://www.youtube.com/@NASA, …/@NASA/shorts, youtube.com/c/… or a legacy youtube.com/name link), an @handle, a channel id (UC…) or a channel name. Links to other sites (TikTok, Instagram, websites) are skipped with a note. One per line.",
            "items": {
              "type": "string"
            }
          },
          "searchQueries": {
            "title": "🔎 Search Shorts",
            "type": "array",
            "description": "Keywords or #hashtags to search YouTube Shorts for (YouTube's own \"Shorts\" search filter, so every result is a Short). One per line.",
            "items": {
              "type": "string"
            }
          },
          "shortsUrls": {
            "title": "🔗 Shorts URLs",
            "type": "array",
            "description": "Individual Shorts: youtube.com/shorts/… links, youtu.be links, watch links or 11-character video ids. A regular (non-Short) video is not saved: it is listed in FAILED_INPUTS as NOT_A_SHORT. One per line.",
            "items": {
              "type": "string"
            }
          },
          "maxResults": {
            "title": "Max Shorts per channel or search",
            "minimum": 1,
            "maximum": 1000,
            "type": "integer",
            "description": "How many Shorts to read from each channel and each search (Shorts URLs are always read in full). You pay per Short saved, plus a small check per channel or search.",
            "default": 20
          },
          "newerThan": {
            "title": "Newer than",
            "type": "string",
            "description": "Only Shorts published on or after this day — a date (2026-09-01) or an age (\"7 days\", \"2 weeks\", \"today\"). The filter works to the day (YouTube shows a Short's publish date, not its time): an age counts back to the start of that calendar day (UTC), so \"1 hour\" keeps everything published today. Channels are then read newest first and stop at the date; searches use YouTube's upload-date filter and the exact publish day. Older Shorts are never charged."
          },
          "channelSortBy": {
            "title": "Channel Shorts order",
            "enum": [
              "newest",
              "popular",
              "oldest"
            ],
            "type": "string",
            "description": "The three buttons on a channel's Shorts tab: newest first, most popular first, or oldest first.",
            "default": "newest"
          },
          "searchSortBy": {
            "title": "Search order",
            "enum": [
              "relevance",
              "popular"
            ],
            "type": "string",
            "description": "Order of Shorts search results: most relevant first (YouTube's default) or most popular first. YouTube offers no upload-date order for Shorts — use \"Newer than\" instead.",
            "default": "relevance"
          },
          "country": {
            "title": "Country",
            "type": "string",
            "description": "Two-letter country code (US, GB, IN, BR, DE …). Searches run as YouTube does for people in that country.",
            "default": "US"
          },
          "proxyConfiguration": {
            "title": "Proxy",
            "type": "object",
            "description": "YouTube is read through Apify datacenter IPs first (cheapest); this proxy (residential by default) is used only for the kinds of request YouTube blocks on datacenter IPs. An account without residential proxies falls back to Apify datacenter IPs automatically. \"Own proxies\" are used for every request.",
            "default": {
              "useApifyProxy": true,
              "apifyProxyGroups": [
                "RESIDENTIAL"
              ]
            }
          },
          "maxConcurrency": {
            "title": "Parallel requests",
            "minimum": 1,
            "maximum": 20,
            "type": "integer",
            "description": "How many Shorts of one channel, search or URL list are read at once (1–20). Channels and searches are also read side by side (up to 8 at a time).",
            "default": 8
          }
        }
      },
      "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

YouTube Shorts Scraper: Views, Music & Hashtags, No API Key OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for YouTube Shorts Scraper — Views, Music & Hashtags, No Login from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

YouTube Shorts Scraper — Views, Music & Hashtags, No Login API in Python

YouTube Shorts Scraper — Views, Music & Hashtags, No Login API in JavaScript

YouTube Shorts Scraper — Views, Music & Hashtags, No Login API through CLI

YouTube Shorts Scraper — Views, Music & Hashtags, No Login API

Keyword Search Volume — Bulk Google Metrics (CPC & Trend)

aitorsm/keyword-volume

Check Google keyword search volume, CPC & competition in bulk — real Keyword Planner data, no Google Ads account needed. 12-month trend per keyword, country/language targeting, plus an Ideas mode that expands seeds into related keywords.

Aitor Sanchez-Mansilla

1.8K

Fast YouTube Channel Scraper API | Profiles, Subs & Stats

apidojo/youtube-channel-information-scraper

Extreme flexibility with search functionalities enables you to retrieve extensive channel information in detail. Not just that but YouTube Channel Information Scraper offers you Country, Language, and Location geo-targeting capabilities. Only $0.50 per 1000 channels!

API Dojo

2.6K

5.0

(8)

YouTube Scraper

streamers/youtube-scraper

YouTube crawler and video scraper. Alternative YouTube API with no limits or quotas. Extract and download channel name, likes, number of views, and number of subscribers.

Streamers

155K

4.8

(196)

RAG Web Browser

apify/rag-web-browser

Web search and fetch tool for AI agents and RAG pipelines. It queries Google Search, scrapes the top N pages using a full web browser, and returns their content as clean Markdown for further processing by an LLM. Can also fetch individual URLs.

Apify

192K

4.7

(35)

YouTube Hashtag Shorts/Videos Scraper #️⃣📺 (All-in-one)

scrapestorm/youtube-hashtag-shorts-videos-scraper-all-in-one

Get Unlimited YouTube Trends Access with Our Alternative API: 🧑‍💻 Seamlessly crawl and scrape YouTube Trending Videos/Shorts by hashtag, to retrieve and download essential information such as the title 📺, view count 👀, and Short URL 📊, with no restrictions or quotas 🚫.

Storm_Scraper

YouTube Shorts Scraper

automation-lab/youtube-shorts-scraper

Scrape YouTube Shorts from any channel. Get exact view counts, likes, comments, publish dates, descriptions, and thumbnails. Pure HTTP — no browser overhead. Supports multiple channels per run. Export JSON, CSV, Excel.

Automation Lab

Instagram Reel Scraper

apify/instagram-reel-scraper

Scrape or download Instagram reels. Just add Instagram profile or reel URL, and get caption, timestamp, transcript, hashtags, mentions, tagged users, comments, likes, shares, views, duration, and downloaded video. Export scraped data, schedule via API, and integrate with other tools or AI workflows.

Apify

163K

4.4

(103)

YouTube Shorts Scraper - Channels & Hashtags

newbs/Youtube-Shorts

Extract YouTube Shorts from channels, hashtags, or video URLs. Collect titles, views, likes, publish dates, and available creator data. Paginate up to 1,000 Shorts per source and export JSON, CSV, or Excel. No YouTube API key required. $3 per 1,000 video results plus Apify usage.

Newbs

444

1.8

(3)

YouTube Video Scraper

clappi/youtube-video-scraper

Extract YouTube video and shorts data. Get title, description, views, likes, comments count, duration, publish date, thumbnails, channel name, subscriber count, and more. No limits or quotas. Download the data in JSON, CSV, and Excel.

Clappi

YouTube Shorts Scraper - Search, Hashtags, Channels ($1/1K)

coiled_magistrate/youtube-shorts-fast

Scrape YouTube Shorts by keyword, #hashtag or channel: views, likes, comments, publish date, duration, hashtags, description and channel subscribers. $1 per 1,000 Shorts, pay only for results.