# YouTube Shorts Analytics — Exact View Counts (`thequietstack/youtube-shorts-analytics`) Actor

Get the exact view count of a YouTube Short, not the rounded "19M views" the channel page shows. Plus likes, engagement rate, publish date, age and a real date filter.

- **URL**: https://apify.com/thequietstack/youtube-shorts-analytics.md
- **Developed by:** [TheQuietStack](https://apify.com/thequietstack) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 analyzed shorts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Shorts Analytics — Exact View Counts

YouTube's channel page shows you **"19M views"**. The Short itself carries **19,098,265**.
Most scrapers read the channel page and hand you the rounded number. This Actor returns both,
side by side, so you can see what the rounding costs you.

Measured across one real run over the @MrBeast Shorts tab, 2026-08-13:

| Short | `views` (exact) | `viewsRounded` | `viewsRoundingLostPct` |
|---|---|---|---|
| POV: You Time Traveled Back to 2016 | **15,876,054** | 15M views | **5.52 %** |
| Asking My Fiancée on a Date | **18,759,779** | 18M views | **4.05 %** |
| Read My Book, You Could Win $1,000,000 | **19,780,917** | 19M views | **3.95 %** |

On the first one the rounded number hides **876,054 views**. Three Shorts that each read
"19M views" on the channel page were 19.2M, 19.8M and 18.5M — a spread of 1.3 million that
the rounded number makes invisible. Sort a spreadsheet by it and the order is simply wrong.

### Built for Shorts, not bolted onto a video scraper

The best-rated YouTube Actor on the store is rated 4.9★ and still gets told, word for word,
*"Hard to use in shorts section"*. Shorts are the main case here, not an afterthought:

- **Deeper than one page.** A channel's Shorts tab lists about 48 Shorts. This Actor follows
  YouTube's own pagination and keeps loading until it has as many as you asked for — measured
  96 listed for @MrBeast in a single extra request. Ask for 200 and you get 200, not 48.
- **One HTTP request per Short.** No browser, no 3 GB of RAM, no "internal server error".
- **Real date filter.** `sinceDate` / `untilDate` on the actual publish date, plus `ageHours`
  on every row so you can see at a glance how fresh the data is.
- **Duplicates are never charged.** Deduplicated by video ID **before** billing, along with
  everything a filter removed.
- **Hard cost cap.** `maxCostUsd` stops the run cleanly at your limit.

### What you get per Short

`videoId` · `url` · `title` · `channel` · `channelId` · `views` · `viewsRounded` ·
`viewsRoundingLostPct` · `likes` · `comments` · `engagementRatePctOfViews` · `publishedAt` ·
`ageHours` · `lengthSeconds` · `isShort` · `category` · `keywords` · `description`

> **Honest note on likes.** YouTube does not put the like count in the same payload as the view
> count. This Actor reads it from the page's own like counter and returns `null` when the page
> does not carry it — never guessed, never derived from views.

### Input

```json
{
    "channels": ["MrBeast", "@veritasium"],
    "maxShortsPerChannel": 30,
    "sinceDate": "2026-06-01",
    "minViews": 100000,
    "maxCostUsd": "1.00"
}
```

You can also pass single Shorts directly via `videoUrls` — `/shorts/` links, watch links,
youtu.be links or bare video IDs all work.

Channels without Shorts are reported with an explicit reason in the run's `SUMMARY` record —
never a silent empty result.

### Pricing

Pay per result: **$2.50 per 1,000 Shorts returned**. Apify platform usage is included in that
price. Filtered-out Shorts and duplicates are not billed.

### Limits, stated up front

- Reads the Shorts tab of a channel, newest first, and pages through it up to
  `maxShortsPerChannel` (max 200). Channels with a very long Shorts history are cut off at that
  limit — by design, so a run can never surprise you with its size.
- Public channels only.
- Comment counts are not exposed on every Short and are `null` when missing. No estimate is
  invented for them.

# Actor input Schema

## `channels` (type: `array`):

Channel handles with or without @, or full channel URLs. Their Shorts tab is read.

## `videoUrls` (type: `array`):

Analyse specific Shorts directly. Accepts /shorts/ URLs, watch URLs, youtu.be links or bare video IDs.

## `maxShortsPerChannel` (type: `integer`):

How many Shorts to return per channel. You are charged per returned Short only - duplicates and filtered-out Shorts are never charged.

## `onlyShorts` (type: `boolean`):

Skip anything longer than 183 seconds, which is no longer a Short.

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

Skip Shorts below this view count. Filtered-out Shorts are not charged.

## `sinceDate` (type: `string`):

Real date filter on the publish date - the single most requested missing feature in competing scrapers.

## `untilDate` (type: `string`):

Optional upper bound for the publish date.

## `maxCostUsd` (type: `string`):

The run stops cleanly when this amount is reached. Leave empty for no cap.

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

Datacenter proxy is enough for this Actor - measured, no residential proxy required.

## Actor input object example

```json
{
  "channels": [
    "MrBeast",
    "@veritasium"
  ],
  "videoUrls": [
    "https://www.youtube.com/shorts/LiH-P4rSkLI"
  ],
  "maxShortsPerChannel": 30,
  "onlyShorts": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `shorts` (type: `string`):

One row per Short: exact views, rounded views, likes, engagement rate, age.

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

Channels processed, Shorts written, amount charged, and the reason for every skipped channel.

# 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 = {
    "channels": [
        "MrBeast"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("thequietstack/youtube-shorts-analytics").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 = {
    "channels": ["MrBeast"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("thequietstack/youtube-shorts-analytics").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 '{
  "channels": [
    "MrBeast"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call thequietstack/youtube-shorts-analytics --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thequietstack/youtube-shorts-analytics"
        }
    }
}

```

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/ikohfLvD7BVjg3Kbh/builds/M9wrE0RbzJcsbjagG/openapi.json