~ / endpoints / Shorts API

YouTube Shorts Scraper API

Our YouTube Shorts scraper takes one Short's id or URL and returns that Short as clean JSON: title, view count, likes, duration, channel, description, keywords, thumbnail, plus an is_short flag and a related videos array. Proxies, anti-bot, and rendering are handled, so one request with your API key is the whole integration.

Get a free API key All endpoints

1,000

free requests / mo

2.6s

median response

JSON

structured output

request per Short

the problem

Why YouTube Shorts data is hard to get

A YouTube Short lives at youtube.com/shorts/<id>, and the view count, likes, duration, and description sit inside a JSON blob the page ships called ytInitialPlayerResponse, not in plain HTML tags, so a single fetch hands you a regex-and-parse job that breaks when the markup shifts. The official YouTube Data API v3 has no Shorts concept at all: you read a Short through videos.list like any other video, after a Google Cloud project, OAuth, and a 10,000-unit daily quota.

quickstart

The YouTube Shorts Scraper API in one request

cURL

curl "https://api.youtubescraperapi.com/api/v1/youtube/shorts?video_id=YA_kX8hu1gg&api_key=$API_KEY"

Python

import requests, os

resp = requests.get(
    "https://api.youtubescraperapi.com/api/v1/youtube/shorts",
    params={
        "video_id": "YA_kX8hu1gg",   # or url=https://www.youtube.com/shorts/<id>
        "api_key": os.environ["API_KEY"],
    },
    timeout=30,
)
short = resp.json()

print(short["title"], "-", short["view_count"], "views")
print("Likes:", short["like_count"], "Duration:", short["duration_seconds"], "s")
print("Is short:", short["is_short"], "Related:", short["related_count"])

for r in short["related"][:3]:
    print(r["position"], r["views"], r["title"])

parameters

Parameters

Parameter	Required	Default	Notes
`video_id`	optional	-	The 11-character id of the Short, e.g. `YA_kX8hu1gg`. Pass either `video_id` or `url`.
`url`	optional	-	A Short's URL instead of a bare id. Accepts a `/shorts/<id>` link, a `watch?v=` URL, a `youtu.be` link, or a bare 11-character id. The id is parsed out of it.
`api_key`	required	-	Your API key, passed as a query parameter. Get one free at signup.

response

What the YouTube Shorts Scraper API returns

200 OK

{
  "video_id": "YA_kX8hu1gg",
  "url": "https://www.youtube.com/watch?v=YA_kX8hu1gg",
  "type": "video",
  "title": "This Plane Takes Off in 12 Seconds",
  "description": "Learn more at lowes.com/kidsclub #lowespartner",
  "view_count": 11746153,
  "like_count": 375941,
  "comment_count": null,
  "duration_seconds": 19,
  "keywords": [],
  "category": "Entertainment",
  "publish_date": "2026-06-26T09:00:01-07:00",
  "channel_id": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "channel_name": "MrBeast",
  "thumbnail": "https://i.ytimg.com/vi/YA_kX8hu1gg/hq720.jpg",
  "is_short": true,
  "related_count": 12,
  "related": [
    {
      "position": 1,
      "id": "0chFUzB8Vco",
      "title": "Countries Compete in World Cup for $10,000",
      "url": "https://www.youtube.com/watch?v=0chFUzB8Vco",
      "channel": "Karl",
      "views": "309K views",
      "published": null,
      "thumbnail": "https://i.ytimg.com/vi/0chFUzB8Vco/hq720.jpg"
    },
    {
      "position": 2,
      "id": "iYlODtkyw_I",
      "title": "Survive 30 Days Chained To A Stranger, Win $250,000",
      "url": "https://www.youtube.com/watch?v=iYlODtkyw_I",
      "channel": "MrBeast",
      "views": "22M views",
      "published": null,
      "thumbnail": "https://i.ytimg.com/vi/iYlODtkyw_I/hq720_custom_1.jpg"
    }
  ]
}

Field	Type	Description
`video_id`	string	The 11-character YouTube id of the Short.
`title`	string	The Short's title as shown on the page.
`description`	string	The Short's full description text.
`view_count`	integer	Lifetime view count at request time.
`like_count`	integer	Public like count at request time.
`comment_count`	integer	Number of comments, or `null` when YouTube does not expose it on the Short.
`duration_seconds`	integer	Runtime of the Short in seconds (Shorts are 180 seconds or less).
`keywords`	array of strings	The tags the uploader set on the Short, if any.
`category`	string	YouTube category name, such as Entertainment or Music.
`publish_date`	string	ISO 8601 timestamp of when the Short was published.
`channel_id`	string	The channel id that owns the Short.
`channel_name`	string	The display name of the channel.
`thumbnail`	string (url)	URL of the highest-resolution thumbnail available.
`is_short`	boolean	Always `true` for this endpoint, confirming the id resolved to a Short.
`related`	array	Videos YouTube surfaces alongside the Short, each with `position`, `id`, `title`, `url`, `channel`, `views`, `published`, and `thumbnail`.
`related_count`	integer	Number of items in the `related` array.

use cases

What you can build using the API

Short performance tracking

Poll a Short's view_count, like_count, and comment_count over time to chart how a single short-form video gains traction after it goes live.

Metadata enrichment

Resolve a list of Short ids or URLs into titles, channels, durations, descriptions, and publish dates to enrich a content database, no Google Cloud project required.

Competitive analysis

Pull the view and like counts on a rival's individual Shorts to benchmark which short-form posts are outperforming and study the packaging behind them.

Related-video discovery

Read the related array to map what YouTube surfaces next to a Short, then walk those ids to expand a seed list into a wider crawl.

Dataset building

Collect title, description, keywords, and engagement counts per Short at scale to assemble a structured short-form dataset for research or modeling.

Title and thumbnail studies

Capture each Short's title and thumbnail URL next to its view count to study which packaging patterns correlate with stronger short-form performance.

why youtubescraperapi.com

Why teams choose our YouTube Shorts Scraper API

Pass a /shorts/ link, a watch URL, a youtu.be link, or a bare id and we resolve the Short for you, with no OAuth, no Google Cloud project, and no unit budget to ration. Every request runs through rotating proxies, anti-bot handling, JS rendering, and retries, reading the values YouTube loads into the page JSON and returning validated JSON in about 2.6 seconds.

Full Short object in one call

A single request returns the Short's title, stats, duration, channel, description, keywords, and thumbnail as flat fields, plus is_short and a related array.

Any Short reference resolves

Send a /shorts/ link, a watch?v= URL, a youtu.be link, or a bare 11-character id and we normalize it to the right Short before fetching.

Anti-bot and proxy rotation

Rotating residential and datacenter proxies plus anti-bot handling keep Short requests from getting blocked.

JS rendering built in

We render the Short so the view count, likes, and duration that load late are read out of the page JSON and returned cleanly.

Pay for success

Failed fetches retry across datacenter, residential, and premium proxy tiers, and you are billed only for Shorts that come back.

comparison

YouTube Shorts Scraper API vs the official YouTube API

Factor	Our API	DIY (requests / headless)	YouTube Data API v3
Scrape one Short's data	Yes, full object from id or URL	Regex ytInitialPlayerResponse yourself	videos.list, no Shorts concept
Accepts /shorts/ URLs	Yes, plus watch, youtu.be, bare id	You convert the URL yourself	Id only, you strip it first
Views, likes, duration	Yes, as flat fields	Possible but parser breaks often	Yes, but quota-bound
Related videos	Yes, in the related array	Separate parse of the page	Not returned for a video
Setup	API key only	Proxies, headless browser, parsers	Google Cloud project plus OAuth
Anti-bot and proxies	Built in	You build and maintain it	Not applicable

pricing

Start free, scale when ready

Plan	Price	Best for
Free	1,000 requests	Testing and small jobs
Pro	$0.60 / 1k	Production workloads
Pay-as-you-go	$0.90 / 1k	Spiky or one-off volume

Median response 2.6s. You only pay for successful requests.

FAQ

What is a YouTube Shorts scraper?

A YouTube Shorts scraper is a tool that reads a Short's public data and returns it in a structured format. Our YouTube Shorts scraper API takes a Short's id or URL and returns that one Short as JSON: title, view count, like count, duration, description, keywords, category, channel, and thumbnail, plus an is_short flag and a related array of nearby videos, from a single request.

How do I scrape a YouTube Short without writing a parser?

Send one GET request to our youtube/shorts endpoint with the Short's video_id or url and your API key. We render the Short, rotate proxies, handle anti-bot checks, retry on failure, and read the values out of the page JSON, so you get clean fields back without maintaining a regex against YouTube's changing markup.

Can I pass a /shorts/ URL or do I need the bare id?

Either works. The url parameter accepts a youtube.com/shorts/ link, a regular watch?v= URL, a youtu.be link, or a bare 11-character id, and we parse the id out of it. You can also pass the 11-character id directly in video_id, so a link copied straight from the Shorts player works as is.

What does the related array contain?

The related array holds the videos YouTube surfaces alongside the Short, each with a position, the 11-character id, title, url, channel name, a views display string like 22M views, a published value, and a thumbnail. A related_count field gives the total. It is the same up-next set a viewer would see, so you can walk those ids to widen a crawl.

Does this endpoint list every Short on a channel?

No. This endpoint scrapes one individual Short by its id or URL. To list every Short a creator has posted, use the channel scraper at /youtube-channel-scraper, which walks a channel's tabs and returns the videos with pagination, then feed any Short id back into this endpoint for that Short's full metadata.

Can I get the view and like counts for a Short?

Yes. The response returns view_count and like_count as plain integers at request time, alongside duration_seconds and the channel details. comment_count is included too, though YouTube returns null for it on some Shorts, so handle that field as optional.

What does it cost to scrape a Short?

The free plan includes 1,000 requests per month, and each call returns one Short's full object. Paid usage runs about $0.60 per 1,000 on the Pro plan, or $0.90 per 1,000 pay-as-you-go. Failed requests are never charged, so you only pay for Shorts that actually come back.

Get shorts api as JSON

Free plan, 1,000 requests. No credit card required.

Get a free API key All endpoints