# YouTube Shorts Music & Sound Trend Tracker (`sian.agency/youtube-shorts-sound-trend-tracker`) Actor

Find which songs are blowing up on YouTube Shorts. Map any sound to every viral Short using it. Track adoption volume per track, discover trending audio, surface high-engagement videos by music. For music labels, indie artists, sync scouts and creator-marketing agencies.

- **URL**: https://apify.com/sian.agency/youtube-shorts-sound-trend-tracker.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Videos, Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 viral short attributed to a sounds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Music & Sound Trend Tracker — Map Viral Audio 🎵🚀

[![Store-SIÁN Agency](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store-YouTube Shorts Transcript](https://img.shields.io/badge/Store-YouTube%20Shorts%20Transcript-FF0000)](https://apify.com/sian.agency/youtube-shorts-ai-transcript-and-metadata-extractor?fpr=sian) [![Store-YouTube Auto Complete](https://img.shields.io/badge/Store-YouTube%20Auto%20Complete-FF0000)](https://apify.com/sian.agency/youtube-auto-complete-and-query-suggestion?fpr=sian) [![Store-TikTok AI Transcript](https://img.shields.io/badge/Store-TikTok%20AI%20Transcript-25F4EE)](https://apify.com/sian.agency/best-tiktok-ai-transcript-extractor?fpr=sian)

#### 🎉 The ONLY actor that maps Shorts sounds → viral Shorts — for music labels, sync scouts & indie artists
##### Feed one Short. Get every viral Short using the same sound. Plus sound metadata, artist info & adoption volume.

---

### 📋 Overview

**Stop guessing which songs are blowing up on YouTube Shorts.** This is the first and only Apify actor that exposes YouTube's native sound-attribution feed — feed any Short, harvest every viral Short using the same audio, and read the exact "total Shorts using this sound" virality signal that A&R teams pay thousands for elsewhere.

**Why music labels, agencies & indie artists choose us:**
- ✅ **Zero-competition data feed**: confirmed via marketplace scan — no other Apify actor exposes the YouTube Shorts sound-attribution endpoint. Pure greenfield, first-mover authority.
- ⚡ **Bulk-friendly pagination**: ~15–16 viral Shorts per page, up to 50 pages per run = up to 800 Shorts mapped per single run.
- 🎯 **Rich sound metadata**: artist channel, sound source video, "1.5M Shorts" total-adoption text, artist avatar — everything you need to build dashboards or label-side intelligence stacks.
- 💰 **Mid-market pricing wedge**: from $0.006 per sound-attribution row — 3–10× cheaper than adjacent TikTok sound trackers ($0.02–$0.06 per row). Tiered ladder to $0.003 at high volume.
- 💎 **Clean dataset shape**: curated camelCase fields (`soundTitle`, `soundArtistChannelTitle`, `soundTotalShortsUsingItText`, `shortPageUrl`) — ready for BigQuery, Snowflake, Sheets, or any downstream BI tool.
- ✨ **NEW**: built-in handling for "no sound attribution" Shorts (silent or non-attributed audio) — no wasted charges, surfaced as status rows in the dataset.

---

### ✨ Features

- 🎵 **Sound Attribution Feed**: paginated list of viral Shorts attributed to any sound, seeded by a single Short ID.
- 🎬 **Short Detail Mode**: full Short metadata in one row — title, channel, views, likes, comments, publish date, family-safe flag, captions, keywords, sound attribution.
- 🔥 **Total-Shorts Virality Signal**: human-readable `soundTotalShortsUsingItText` (e.g. `"1.5M Shorts"`) — the same metric YouTube displays to creators.
- 🎤 **Artist Intelligence**: sound's source channel ID, channel title, avatar URL, and source Short URL — handy for sync-licensing prospecting.
- 🌍 **Geo + Language Localization**: pass `geo` (e.g. `US`, `GB`, `IN`, `BR`, `JP`) and `lang` to surface region-specific trending.
- 📄 **Pagination Control**: hard-cap at 50 pages with sensible defaults; pause early via `maxPages`.
- 🧹 **Smart Status Rows**: silent Shorts and non-attributed audio get a `no_sound_attribution` row — never an opaque error.
- 📦 **Schema-Stable Output**: every row matches a published dataset schema — predictable for downstream ETL.
- 🛡️ **No Account, No API Key, No Proxies**: just an Apify token and you're scraping.

---

### 🎬 Quick Start

Pick a seed Short, pick an operation, and run. Get a clean dataset back in seconds — ready to export to JSON, CSV, or Excel.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~youtube-shorts-sound-trend-tracker/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"operation":"soundAttribution","shortId":"fHI8X4OXluQ","maxPages":5}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Find a seed Short

Open any YouTube Shorts URL — the 11-character ID after `/shorts/` is your seed. Pick a Short that uses the sound or song you want to investigate.

#### Step 2: Choose your operation

- **`soundAttribution`** — paginated list of viral Shorts using the same audio (best for volume).
- **`shortDetail`** — full metadata for the seed Short itself (best for sound discovery / enrichment).

#### Step 3: Run it

Pass `shortId` (required), `maxPages` (optional, 1–50), `geo` (optional country code) and `lang` (optional language code). Hit run.

**That's it! In under a minute, you'll have:**

- A clean dataset of every viral Short attributed to your seed sound
- Sound metadata: title, artist, total adoption volume, source video
- Per-row Short data: channel, view counts, thumbnails, publish dates, page URLs

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `operation` | string | Yes | `soundAttribution` (bulk viral Shorts) or `shortDetail` (single Short metadata) |
| `shortId` | string | Yes | 11-character YouTube Shorts video ID (the part after `/shorts/` in the URL) |
| `maxPages` | integer | No | Pages to fetch for `soundAttribution` (default 5, max 50). Ignored for `shortDetail`. |
| `geo` | string | No | ISO 3166-1 alpha-2 country code (e.g. `US`, `GB`, `IN`). Defaults to `US`. |
| `lang` | string | No | ISO 639-1 language code (e.g. `en`, `es`, `pt`). Defaults to `en`. |

**Example — find viral Shorts using a seed sound:**

```json
{
  "operation": "soundAttribution",
  "shortId": "fHI8X4OXluQ",
  "maxPages": 10,
  "geo": "US"
}
```

**Example — pull full metadata for one Short:**

```json
{
  "operation": "shortDetail",
  "shortId": "fHI8X4OXluQ"
}
```

***

### 📤 Output

Results are saved to the Apify dataset with **30+ fields** including:

| Field | Type | Description |
|-------|------|-------------|
| `shortId` | string | YouTube Shorts video ID of the attributed Short |
| `shortPageUrl` | string | Canonical `youtube.com/shorts/{id}` URL |
| `channelTitle` | string | Channel that posted the Short |
| `channelId` | string | Channel ID |
| `channelPageUrl` | string | Canonical channel URL |
| `viewCount` | integer | Parsed view count (numeric) |
| `viewCountText` | string | Raw view-count text (e.g. `"6.8M views"`) |
| `thumbnailUrl` | string | Highest-resolution thumbnail |
| `isOriginalAspectRatio` | boolean | Whether the Short is in native vertical aspect ratio |
| `soundTitle` | string | Title of the original sound (e.g. `"Blinding Lights"`) |
| `soundArtistChannelTitle` | string | Channel/artist owning the sound (e.g. `"The Weeknd"`) |
| `soundArtistChannelId` | string | Sound owner's channel ID |
| `soundSourceShortId` | string | Video ID of the original sound source |
| `soundSourceUrl` | string | URL of the sound's source video |
| `soundTotalShortsUsingItText` | string | Human-readable adoption volume (e.g. `"1.5M Shorts"`) |
| `status` | string | `success`, `error`, or `no_sound_attribution` |

**Example row (`soundAttribution`):**

```json
{
  "_operation": "soundAttribution",
  "_page": 1,
  "_sourceShortId": "fHI8X4OXluQ",
  "status": "success",
  "shortId": "B7hFpaU7uXk",
  "shortPageUrl": "https://www.youtube.com/shorts/B7hFpaU7uXk",
  "viewCount": 6800000,
  "viewCountText": "6.8M views",
  "thumbnailUrl": "https://i.ytimg.com/vi/B7hFpaU7uXk/frame0.jpg",
  "soundTitle": "Blinding Lights",
  "soundArtistChannelTitle": "The Weeknd",
  "soundArtistChannelId": "UC0WP5P-ufpRfjbNrmOWwLBQ",
  "soundSourceShortId": "4NRXx6U8ABQ",
  "soundSourceUrl": "https://www.youtube.com/shorts/4NRXx6U8ABQ",
  "soundTotalShortsUsingItText": "395K Shorts"
}
```

***

### 💼 Use Cases & Examples

#### 1. Music Label A\&R — Track Roster Adoption

**Music label A\&R teams use this to measure organic Shorts adoption of every track on the roster.**

**Input:** A Short featuring your artist's release.
**Output:** Every viral Short using the same audio, with view counts and adoption-volume text.
**Use:** Build a daily/weekly dashboard of which roster tracks are gaining traction on Shorts — surface organic momentum before it hits playlists.

#### 2. Sync-Licensing Scout — Find Rising Audio

**Sync-licensing scouts use this to discover sounds going viral before they hit mainstream radar.**

**Input:** A trending Short you've spotted on the For You feed.
**Output:** Sound's artist channel, source video, and current adoption volume.
**Use:** Identify rising unlicensed audio early and pitch licensing deals before competitors notice.

#### 3. Indie Artist Marketing — Own the Discovery Loop

**Indie artists use this to see exactly who's using their release on Shorts.**

**Input:** A Short featuring your own track (your reference upload).
**Output:** Every cover, reaction, and creator video using your audio.
**Use:** Identify top-performing creators using your music, then comment / collab / amplify.

#### 4. Music Marketing Agency — Creator-Seeding Campaigns

**Marketing agencies use this to spot which sounds are blowing up across creators.**

**Input:** A seed Short for the genre/mood you're seeding.
**Output:** Ranked list of viral Shorts and creators already adopting the sound.
**Use:** Build creator-seeding campaigns on the next wave of trending audio instead of chasing yesterday's trends.

#### 5. Trend Forecasting & Insights Teams — Surface Emerging Audio

**Trend forecasting teams use this to feed dashboards that surface rising sounds early.**

**Input:** Weekly batch of trending Shorts across niches.
**Output:** Per-sound adoption-volume signals, artist intelligence, viral creator examples.
**Use:** Power "what's blowing up on Shorts this week" reports for label clients, music supervisors, and ad agencies.

#### 6. Brand Sound-Strategy Teams — License Before Competitors

**Brand sound-strategy teams use this to scout rising audio for ad work.**

**Input:** Trending Shorts from your target demographic.
**Output:** Sounds reaching critical mass, plus the artist channels behind them.
**Use:** Build a licensing pipeline for trending audio you can use in upcoming ad campaigns before rivals do.

#### 7. Music Discovery Platforms — Cold-Start Recommendation Data

**Music discovery platforms use this for cold-start recommendation data.**

**Input:** Anchor Shorts seeded from your existing recommendation graph.
**Output:** Co-occurrence map of sounds and creators on YouTube Shorts.
**Use:** Bootstrap or augment recommendation models with real cross-creator audio adoption signals.

***

### 🔗 Integration Examples

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/youtube-shorts-sound-trend-tracker').call({
  operation: 'soundAttribution',
  shortId: 'fHI8X4OXluQ',
  maxPages: 10
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} viral Shorts attributed to sound "${items[0]?.soundTitle}"`);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/youtube-shorts-sound-trend-tracker').call(
    run_input={
        'operation': 'soundAttribution',
        'shortId': 'fHI8X4OXluQ',
        'maxPages': 10,
    }
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['shortId'], item.get('viewCountText'), '—', item.get('soundTitle'))
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~youtube-shorts-sound-trend-tracker/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"operation":"soundAttribution","shortId":"fHI8X4OXluQ","maxPages":5}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule (e.g. daily 9am) or manual webhook
2. **HTTP Request**: Call this actor's run API with a seed `shortId`
3. **Process**: Iterate the dataset rows in your workflow
4. **Action**: Push to Google Sheets, Slack, Notion, BigQuery, or your CRM

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **~3 sound-attribution rows or 1 short-detail row** covered by Apify's monthly free credit — full feature access, same data quality.
- No credit card required.
- Perfect for one-off lookups and pilot evaluations.

#### PAID Tier (Production-Ready)

- **Unlimited** sound-attribution rows per run, ladder pricing scales down at volume.
- Pay-per-event: only charged for successful rows (silent / no-sound Shorts cost nothing).

**Pricing Highlights — `sound-attribution-row` (headline):**

- BRONZE: `$0.006` per viral-Short row
- SILVER: `$0.0045` per row
- GOLD / PLATINUM / DIAMOND: `$0.003` per row

**Detail mode — `short-detail-result`:**

- BRONZE: `$0.020` per full-Short row
- GOLD / PLATINUM / DIAMOND: `$0.015` per row

💰 **3–10× cheaper than adjacent TikTok sound trackers** (which charge $0.02–$0.06 per row). The only YouTube Shorts sound mapper on Apify, priced as a wedge to lock the category.

🔗 [View live pricing](https://apify.com/sian.agency/youtube-shorts-sound-trend-tracker?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: How many viral Shorts can I get per run?**
A: Up to ~800 (50 pages × ~16 rows/page). Most popular sounds easily fill all 50 pages — viral audio routinely shows 100K–1.5M+ total Shorts available.

**Q: What if my seed Short has no sound attribution (silent video / non-attributed audio)?**
A: You'll get a single `no_sound_attribution` status row, with a clear message. No charge for that row.

**Q: How do I find a good seed Short?**
A: Any Short that uses the sound you want to investigate. Easiest: open YouTube Shorts, find a video using the audio, copy the 11-char ID from its URL.

**Q: Does this work for songs from major artists like Taylor Swift, The Weeknd, Bad Bunny?**
A: Yes — any sound with YouTube attribution works. Major-artist tracks often have millions of attributed Shorts.

**Q: Can I monitor sound trends over time?**
A: Yes — schedule the actor on Apify (or your own scheduler) to re-run with the same seed daily/weekly and track `soundTotalShortsUsingItText` deltas.

**Q: What output formats are available?**
A: JSON, CSV, Excel, RSS, HTML — export directly from the Apify dataset.

**Q: How long does a 10-page run take?**
A: Typically 20–40 seconds end-to-end.

**Q: Is this legal?**
A: Yes — we only extract publicly available data that YouTube already exposes to every Shorts viewer. See our legal section below.

*YouTube and YouTube Shorts are trademarks of Google LLC. This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Google LLC.*

***

### 🐛 Troubleshooting

**"Invalid Short ID" error**

- YouTube Shorts video IDs are 11 characters of alphanumerics, dashes, and underscores. Copy the segment after `/shorts/` in the URL — don't include the URL itself.

**`status: no_sound_attribution` rows only**

- Your seed Short doesn't have a recognized original sound (silent video, non-attributed audio, or attribution was removed). Try a different Short that you know uses a song or trending sound.

**Empty dataset / 0 rows**

- Verify the Short ID is correct by opening `https://www.youtube.com/shorts/{ID}` in a browser. If the video plays, your ID is valid.

**Pagination stops earlier than `maxPages`**

- That's expected — the run stops when YouTube signals no more results for that sound, or when the sound has fewer attributed Shorts than `maxPages × 16`.

**Geo / language not returning local results**

- Some sounds trend globally; `geo` and `lang` only adjust localization. The underlying sound-attribution feed is the same across regions for most popular sounds.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- ✉️ <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.

- **🎵 Sound Attribution (Viral Shorts by Sound)** — pass a seed Short → get the full paginated list of viral Shorts using the same sound, plus sound metadata (artist, source video, total Shorts using it).
- **🎬 Short Detail** — deep metadata for a single Short by ID (title, channel, views, comments, sound attribution, publish date, thumbnails).

💡 **TIP:** Start with `Sound Attribution` to discover viral Shorts by sound. Then run `Short Detail` per `shortId` to enrich top hits with full metadata.

## `shortId` (type: `string`):

🎬 **Required for both operations.**

The 11-character YouTube Shorts video ID. You can find it:

- In any Shorts URL: `https://www.youtube.com/shorts/{ID}` → the trailing segment
- In the `shortId` / `videoId` field of any result row from this actor or any YouTube scraper

💡 **TIP:** Use a Short you know features the sound you want to investigate. The actor reads the Short's audio attribution and harvests every other viral Short using the same sound.

ℹ️ Some Shorts have no sound attribution (silent videos or non-attributed audio). The actor will save a `no_sound_attribution` status row in that case — no charge.

## `maxPages` (type: `integer`):

📄 **Applies to `Sound Attribution`.** Ignored for `Short Detail` (single-row).

- **Sound Attribution:** ~15–16 Shorts per page

Viral sounds can have **hundreds of thousands to millions** of Shorts attributed. Start small (3–10 pages = 45–160 rows) to preview velocity and spend before scaling.

⚠️ Hard cap: 50 pages to prevent runaway runs.

## `geo` (type: `string`):

🌍 **Optional.** Two-letter country code to localize results. Defaults to `US`.

Examples: `US` (United States), `GB` (United Kingdom), `IN` (India), `BR` (Brazil), `DE` (Germany), `JP` (Japan), `KR` (Korea), `MX` (Mexico).

💡 Useful when the same sound trends differently per region.

## `lang` (type: `string`):

🗣 **Optional.** Two-letter language code for localized labels. Defaults to `en`.

Examples: `en`, `es`, `pt`, `hi`, `ja`, `ko`.

## Actor input object example

```json
{
  "operation": "soundAttribution",
  "shortId": "jOcyYhsc1mA",
  "maxPages": 5,
  "geo": "US",
  "lang": "en"
}
```

# Actor output Schema

## `output` (type: `string`):

Viral Shorts attributed to a sound, or full metadata for one Short — one row per item with curated camelCase fields (shortId, shortPageUrl, viewCount, soundTitle, soundArtistChannelTitle, soundTotalShortsUsingItText, …).

## `report` (type: `string`):

HTML report with run status, success/error/no-sound counts, success rate, pages fetched, sound metadata, duration, and inputs — written even on fatal crash.

# 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 = {
    "shortId": "jOcyYhsc1mA"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/youtube-shorts-sound-trend-tracker").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 = { "shortId": "jOcyYhsc1mA" }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/youtube-shorts-sound-trend-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "shortId": "jOcyYhsc1mA"
}' |
apify call sian.agency/youtube-shorts-sound-trend-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sian.agency/youtube-shorts-sound-trend-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Shorts Music & Sound Trend Tracker",
        "description": "Find which songs are blowing up on YouTube Shorts. Map any sound to every viral Short using it. Track adoption volume per track, discover trending audio, surface high-engagement videos by music. For music labels, indie artists, sync scouts and creator-marketing agencies.",
        "version": "1.0",
        "x-build-id": "xpCEggCIQWwovy1e3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~youtube-shorts-sound-trend-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-youtube-shorts-sound-trend-tracker",
                "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/sian.agency~youtube-shorts-sound-trend-tracker/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-youtube-shorts-sound-trend-tracker",
                "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/sian.agency~youtube-shorts-sound-trend-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-youtube-shorts-sound-trend-tracker",
                "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",
                "required": [
                    "operation",
                    "shortId"
                ],
                "properties": {
                    "operation": {
                        "title": "🎯 Operation — what do you want to scrape?",
                        "enum": [
                            "soundAttribution",
                            "shortDetail"
                        ],
                        "type": "string",
                        "description": "🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.\n\n- **🎵 Sound Attribution (Viral Shorts by Sound)** — pass a seed Short → get the full paginated list of viral Shorts using the same sound, plus sound metadata (artist, source video, total Shorts using it).\n- **🎬 Short Detail** — deep metadata for a single Short by ID (title, channel, views, comments, sound attribution, publish date, thumbnails).\n\n💡 **TIP:** Start with `Sound Attribution` to discover viral Shorts by sound. Then run `Short Detail` per `shortId` to enrich top hits with full metadata.",
                        "default": "soundAttribution"
                    },
                    "shortId": {
                        "title": "🎬 Short ID (YouTube Shorts video ID)",
                        "type": "string",
                        "description": "🎬 **Required for both operations.**\n\nThe 11-character YouTube Shorts video ID. You can find it:\n- In any Shorts URL: `https://www.youtube.com/shorts/{ID}` → the trailing segment\n- In the `shortId` / `videoId` field of any result row from this actor or any YouTube scraper\n\n💡 **TIP:** Use a Short you know features the sound you want to investigate. The actor reads the Short's audio attribution and harvests every other viral Short using the same sound.\n\nℹ️ Some Shorts have no sound attribution (silent videos or non-attributed audio). The actor will save a `no_sound_attribution` status row in that case — no charge."
                    },
                    "maxPages": {
                        "title": "📄 Max pages to fetch",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "📄 **Applies to `Sound Attribution`.** Ignored for `Short Detail` (single-row).\n\n- **Sound Attribution:** ~15–16 Shorts per page\n\nViral sounds can have **hundreds of thousands to millions** of Shorts attributed. Start small (3–10 pages = 45–160 rows) to preview velocity and spend before scaling.\n\n⚠️ Hard cap: 50 pages to prevent runaway runs.",
                        "default": 5
                    },
                    "geo": {
                        "title": "🌍 Country (optional, ISO 3166-1 alpha-2)",
                        "type": "string",
                        "description": "🌍 **Optional.** Two-letter country code to localize results. Defaults to `US`.\n\nExamples: `US` (United States), `GB` (United Kingdom), `IN` (India), `BR` (Brazil), `DE` (Germany), `JP` (Japan), `KR` (Korea), `MX` (Mexico).\n\n💡 Useful when the same sound trends differently per region.",
                        "default": "US"
                    },
                    "lang": {
                        "title": "🗣 Language (optional, ISO 639-1)",
                        "type": "string",
                        "description": "🗣 **Optional.** Two-letter language code for localized labels. Defaults to `en`.\n\nExamples: `en`, `es`, `pt`, `hi`, `ja`, `ko`.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            },
                            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```