# Kworb Music Charts Scraper (`crawlerbros/kworb-music-charts-scraper`) Actor

Scrape Kworb.net music charts - Spotify daily/weekly streaming charts (global + 76 countries), the worldwide Apple Music / iTunes song chart, YouTube's most-viewed music videos, all-time top-streamed Spotify artists, and per-artist song-level streaming stats. No login or proxy required.

- **URL**: https://apify.com/crawlerbros/kworb-music-charts-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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/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

## Kworb Music Charts Scraper

Scrape music streaming charts from [Kworb.net](https://kworb.net) — Spotify daily and weekly charts for 76 countries plus the global aggregate, the worldwide Apple Music / iTunes song chart, YouTube's real-time most-viewed music videos, Shazam and Deezer discovery charts by country, the US radio airplay chart, the all-time top-streamed Spotify artists, a composite cross-platform artist ranking, and per-artist song-level streaming stats. No login, cookies, or paid proxy required.

### What this actor does

- **Nine modes:** `spotifyChart`, `appleMusicChart`, `youtubeChart`, `shazamChart`, `deezerChart`, `radioChart`, `topArtists`, `globalArtistRanking`, `artistStats`
- **Spotify charts** — daily or weekly, global or any of 76 country markets, with position change, days/weeks on chart, peak position, streams, and streams-change deltas
- **Apple Music worldwide chart** — points-based ranking with per-country chart positions (US, UK, Germany, Australia, Japan)
- **YouTube real-time chart** — today's most-viewed music videos, filterable by regional category (English, Spanish, Asian, other)
- **Shazam discovery chart** — what listeners are Shazaming, by country (87 markets + worldwide)
- **Deezer chart** — Deezer's own streaming chart, by country
- **US radio airplay chart** — Billboard-style radio audience data with cross-platform position comparison (iTunes/Spotify/Apple Music/Shazam rank for the same song)
- **Top Spotify artists** — all-time most-streamed artists with lead/solo/feature streaming breakdowns
- **Global cross-platform artist ranking** — kworb's composite "who's biggest right now" leaderboard, combining live points from Apple Music, Spotify, iTunes, YouTube, Shazam, and Deezer into one score, updated every ~15 minutes
- **Per-artist stats** — every tracked song for an artist with lifetime and daily Spotify stream counts
- Empty fields are always omitted — every record only contains data Kworb actually published

### Output: chart entry (mode=spotifyChart)

- `country`, `period` — `daily` or `weekly`
- `platform: "spotify"`
- `rank`, `rankChange` — `+N` / `-N` / `=` / `NEW`
- `artist`, `trackTitle`
- `daysOnChart` (period=daily) / `weeksOnChart` (period=weekly)
- `peakPosition`, `weeksAtPeak`
- `streams`, `streamsChange`
- `sevenDayStreams`, `sevenDayStreamsChange` — period=daily only
- `totalStreams`
- `artistSpotifyId`, `artistUrl` — Spotify artist page
- `chartDate`, `sourceUrl`
- `recordType: "chartEntry"`, `scrapedAt`

### Output: chart entry (mode=appleMusicChart)

- `platform: "apple-music"`
- `rank`, `rankChange`
- `artist`, `trackTitle`
- `daysOnChart`, `peakPosition`, `weeksAtPeak`
- `points`, `pointsChange`
- `positionUS`, `positionUK`, `positionDE`, `positionAU`, `positionJP` — per-country chart position, only present where the song also charts there
- `chartDate`, `sourceUrl`
- `recordType: "chartEntry"`, `scrapedAt`

### Output: chart entry (mode=youtubeChart)

- `category`, `platform: "youtube"`
- `rank`, `rankChange`
- `videoTitle`
- `views`, `likes`
- `videoId`, `videoUrl`
- `chartDate`, `sourceUrl`
- `recordType: "chartEntry"`, `scrapedAt`

### Output: chart entry (mode=shazamChart / deezerChart)

- `platform: "shazam"` / `"deezer"`, `country`
- `rank`, `rankChange`
- `artist`, `trackTitle`
- `chartDate`, `sourceUrl`
- `recordType: "chartEntry"`, `scrapedAt`

### Output: chart entry (mode=radioChart)

- `platform: "radio"`, `country: "us"`
- `rank` — omitted for the unranked "bubbling under" tail (still real published data, just without an official chart position)
- `rankChange`
- `artist`, `trackTitle`
- `daysOnChart`, `peakPosition`, `weeksAtPeak`
- `audienceMillions`, `audienceChange`
- `stationCount`, `peakAudienceMillions`
- `itunesPosition`, `spotifyPosition`, `appleMusicPosition`, `shazamPosition` — cross-platform position for the same song, where Kworb publishes it
- `chartDate`, `sourceUrl`
- `recordType: "chartEntry"`, `scrapedAt`

### Output: artist (mode=topArtists)

- `platform: "spotify"`
- `rank`, `artist`
- `totalStreams`, `dailyStreams` — all-time / daily Spotify streams
- `asLeadStreams`, `soloStreams`, `asFeatureStreams` — streaming breakdown by billing
- `artistSpotifyId`, `artistUrl`
- `sourceUrl`
- `recordType: "artist"`, `scrapedAt`

### Output: artist (mode=globalArtistRanking)

- `rank`, `rankChange`
- `artist`
- `points` — composite cross-platform score
- `pointsAppleMusic`, `pointsSpotify`, `pointsItunes`, `pointsYoutube`, `pointsShazam`, `pointsDeezer` — per-platform point breakdown
- `topCountry` — country where the artist charts highest
- `countriesCharting` — count of countries the artist charts in
- `kworbArtistUrl` — kworb.net's own per-artist detail page (distinct from the Spotify `artistUrl` used by other modes)
- `chartDate`, `sourceUrl`
- `recordType: "artist"`, `scrapedAt`

### Output: artistSummary + song (mode=artistStats)

One `artistSummary` record plus one `song` record per tracked song.

**`artistSummary`:**
- `artistSpotifyId`, `artistUrl`, `sourceUrl`
- `artistName`
- `totalStreams`, `totalStreamsAsLead`, `totalStreamsSolo`, `totalStreamsAsFeature`
- `dailyStreams`, `dailyStreamsAsLead`, `dailyStreamsSolo`, `dailyStreamsAsFeature`
- `trackCount`, `trackCountAsLead`, `trackCountSolo`, `trackCountAsFeature`
- `recordType: "artistSummary"`, `scrapedAt`

**`song`:**
- `rank`, `artistSpotifyId`, `artistName`
- `songTitle`
- `streams`, `dailyStreams`
- `trackUrl` — official Spotify track link
- `sourceUrl`
- `recordType: "song"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `spotifyChart` | `spotifyChart` / `appleMusicChart` / `youtubeChart` / `shazamChart` / `deezerChart` / `radioChart` / `topArtists` / `globalArtistRanking` / `artistStats` |
| `country` | string | `global` | Spotify chart market — 76 countries + `global` (mode=spotifyChart) |
| `period` | string | `daily` | `daily` or `weekly` (mode=spotifyChart) |
| `youtubeCategory` | string | `global` | `global` / `anglo` / `hispano` / `asian` / `other` (mode=youtubeChart) |
| `chartCountry` | string | `us` | Chart market — 87 countries + `ww` worldwide (mode=shazamChart / deezerChart) |
| `artistNames` | array | `["Taylor Swift"]` | One or more artist names to resolve via Kworb's Spotify artist directory, one per entry — batch-lookup multiple artists in one run (mode=artistStats) |
| `spotifyArtistIds` | array | `[]` | One or more direct 22-char Spotify artist IDs, one per entry; processed before `artistNames` (mode=artistStats) |
| `maxItems` | int | `25` | Hard cap on emitted records (1-1000) |

#### Example: global Spotify daily Top 25

```json
{ "mode": "spotifyChart", "country": "global", "period": "daily", "maxItems": 25 }
````

#### Example: UK Spotify weekly chart

```json
{ "mode": "spotifyChart", "country": "gb", "period": "weekly", "maxItems": 50 }
```

#### Example: worldwide Apple Music chart

```json
{ "mode": "appleMusicChart", "maxItems": 50 }
```

#### Example: today's most-viewed music videos

```json
{ "mode": "youtubeChart", "youtubeCategory": "global", "maxItems": 25 }
```

#### Example: an artist's Spotify song catalog

```json
{ "mode": "artistStats", "artistNames": ["Bad Bunny"], "maxItems": 50 }
```

#### Example: batch-compare multiple artists in one run

```json
{ "mode": "artistStats", "artistNames": ["Bad Bunny", "Drake"], "spotifyArtistIds": ["06HL4z0CvFAxyc27GXpf02"], "maxItems": 150 }
```

#### Example: Shazam discovery chart for France

```json
{ "mode": "shazamChart", "chartCountry": "fr", "maxItems": 50 }
```

#### Example: Deezer chart worldwide

```json
{ "mode": "deezerChart", "chartCountry": "ww", "maxItems": 50 }
```

#### Example: US radio airplay chart

```json
{ "mode": "radioChart", "maxItems": 100 }
```

#### Example: global cross-platform artist ranking

```json
{ "mode": "globalArtistRanking", "maxItems": 100 }
```

### Use cases

- **Music industry analytics** — track streaming performance across platforms and markets
- **A\&R and label research** — spot rising tracks/artists by chart movement and streams-change deltas
- **Playlist curation** — surface daily/weekly top movers by country
- **Marketing & PR** — monitor a specific artist's catalog performance over time
- **Competitive benchmarking** — compare an artist's cross-platform reach (Spotify vs Apple Music vs YouTube)

### FAQ

**What's Kworb?** An independent music-data site that aggregates and republishes publicly visible Spotify, Apple Music/iTunes, and YouTube chart data, updated multiple times daily. See [kworb.net](https://kworb.net).

**What countries are supported for Spotify charts?** 76 individual country markets (ISO 3166-1 alpha-2 codes) plus `global`, e.g. `us`, `gb`, `de`, `jp`, `br`, `in`, `mx`. See the `country` dropdown for the full list.

**What does `rankChange` mean?** The position change since the previous chart update: `+N` (moved up), `-N` (moved down), `=` (unchanged), or `NEW` (newly charted).

**Why are `totalStreams` values so large for `topArtists`?** Kworb publishes all-time totals in millions (e.g. `136,904.9` = ~136.9 billion streams); the actor converts this to an absolute stream count for consistency with other modes.

**How do I find a Spotify artist ID?** Run `mode=artistStats` with `artistNames` set — the actor resolves each name against Kworb's Spotify artist directory and returns the ID in the summary record. You can then reuse `spotifyArtistIds` directly on future runs to skip the lookup.

**Can I look up more than one artist in a single run?** Yes — `artistNames` and `spotifyArtistIds` both accept multiple entries. Each artist gets its own `artistSummary` record plus its own song records, all sharing the run's single `maxItems` cap (IDs are processed first, then names, in list order).

**Why is `chartDate` today's date rather than a chart-specific date?** Kworb's chart pages are live snapshots (continuously updated, not archived by date), so `chartDate` reflects when the actor captured the data.

**Is a proxy or login required?** No — Kworb serves full chart data to plain HTTP requests with no login, cookies, or proxy of any kind.

**Are Shazam and Deezer charts available for every country?** Shazam covers 87 markets, Deezer a smaller overlapping set. If a `chartCountry` isn't published for the selected platform, the run returns 0 records with a status message rather than an error — try a different country.

**Why do Spotify daily/weekly charts cap at 200 rows even with a higher `maxItems`?** Kworb's chart pages themselves only publish the top 200 positions per country/period — that's the full dataset the source makes available, not a scraper limitation.

**Why does `globalArtistRanking` cap at 300 rows even with a higher `maxItems`?** Kworb's Global Digital Artist Ranking page itself only publishes the top 300 artists — that's the full dataset the source makes available, not a scraper limitation.

**What about per-country iTunes charts and per-country YouTube "insights" charts?** Kworb also publishes these (`kworb.net/charts/itunes/<cc>.html`, `kworb.net/youtube/insights/<cc>_daily.html`). They're not yet exposed as separate modes since the existing `appleMusicChart` (worldwide, with US/UK/DE/AU/JP position columns) and `youtubeChart` (regional-category) modes cover the same songs/videos at a coarser granularity; full per-country breakouts are a candidate for a future update.

**How is `globalArtistRanking` different from `topArtists`?** `topArtists` is all-time cumulative Spotify streams only. `globalArtistRanking` is a live "who's biggest right now" score combining points from six platforms at once (Apple Music, Spotify, iTunes, YouTube, Shazam, Deezer) — closer to a real-time cross-platform popularity leaderboard than a lifetime totals list.

**What about kworb's live "iTunes popularity bars" (`kworb.net/pop/` and per-country variants)?** This section tracks intraday relative-popularity fluctuations as a 0–1 fraction against a handful of recent snapshot timestamps rather than a clean dated chart, and kworb's own site describes it as the original, most dated part of the site. It isn't exposed as a mode — `appleMusicChart` (worldwide) and `globalArtistRanking` (includes an iTunes points column) already surface the same underlying songs/artists in a more directly usable form.

# Actor input Schema

## `mode` (type: `string`):

Which Kworb chart or dataset to scrape.

## `country` (type: `string`):

Spotify chart market. `global` is the worldwide aggregate chart.

## `period` (type: `string`):

Daily chart (updated daily) or weekly chart (Fri-Thu aggregate).

## `youtubeCategory` (type: `string`):

Kworb's regional split of today's most-viewed music videos on YouTube.

## `chartCountry` (type: `string`):

Country market for the Shazam or Deezer chart. `ww` is Shazam's worldwide chart. Note: Deezer does not publish charts for every country Shazam does (unsupported combinations return no data).

## `artistNames` (type: `array`):

One or more artist names to look up in Kworb's all-time Spotify artist directory (case-insensitive, exact match preferred), one per entry. A batch of names emits one `artistSummary` + song records per artist, up to the shared `maxItems` cap. Alternatively supply `spotifyArtistIds` directly.

## `spotifyArtistIds` (type: `array`):

One or more 22-character Spotify artist IDs, one per entry, e.g. `06HL4z0CvFAxyc27GXpf02` (Taylor Swift). Looked up directly (no directory search needed) and processed before `artistNames`.

## `maxItems` (type: `integer`):

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "spotifyChart",
  "country": "global",
  "period": "daily",
  "youtubeCategory": "global",
  "chartCountry": "us",
  "artistNames": [
    "Taylor Swift"
  ],
  "spotifyArtistIds": [],
  "maxItems": 10
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped Kworb chart/artist records.

# 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 = {
    "mode": "spotifyChart",
    "country": "global",
    "period": "daily",
    "youtubeCategory": "global",
    "chartCountry": "us",
    "artistNames": [
        "Taylor Swift"
    ],
    "spotifyArtistIds": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/kworb-music-charts-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "spotifyChart",
    "country": "global",
    "period": "daily",
    "youtubeCategory": "global",
    "chartCountry": "us",
    "artistNames": ["Taylor Swift"],
    "spotifyArtistIds": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/kworb-music-charts-scraper").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 '{
  "mode": "spotifyChart",
  "country": "global",
  "period": "daily",
  "youtubeCategory": "global",
  "chartCountry": "us",
  "artistNames": [
    "Taylor Swift"
  ],
  "spotifyArtistIds": [],
  "maxItems": 10
}' |
apify call crawlerbros/kworb-music-charts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/kworb-music-charts-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kworb Music Charts Scraper",
        "description": "Scrape Kworb.net music charts - Spotify daily/weekly streaming charts (global + 76 countries), the worldwide Apple Music / iTunes song chart, YouTube's most-viewed music videos, all-time top-streamed Spotify artists, and per-artist song-level streaming stats. No login or proxy required.",
        "version": "1.0",
        "x-build-id": "yDzjU66Id9cx8cIel"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~kworb-music-charts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-kworb-music-charts-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/crawlerbros~kworb-music-charts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-kworb-music-charts-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/crawlerbros~kworb-music-charts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-kworb-music-charts-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "spotifyChart",
                            "appleMusicChart",
                            "youtubeChart",
                            "topArtists",
                            "artistStats",
                            "shazamChart",
                            "deezerChart",
                            "radioChart",
                            "globalArtistRanking"
                        ],
                        "type": "string",
                        "description": "Which Kworb chart or dataset to scrape.",
                        "default": "spotifyChart"
                    },
                    "country": {
                        "title": "Country (mode=spotifyChart)",
                        "enum": [
                            "ad",
                            "ae",
                            "ar",
                            "at",
                            "au",
                            "be",
                            "bg",
                            "bo",
                            "br",
                            "by",
                            "ca",
                            "ch",
                            "cl",
                            "co",
                            "cr",
                            "cy",
                            "cz",
                            "de",
                            "dk",
                            "do",
                            "ec",
                            "ee",
                            "eg",
                            "es",
                            "fi",
                            "fr",
                            "gb",
                            "global",
                            "gr",
                            "gt",
                            "hk",
                            "hn",
                            "hu",
                            "id",
                            "ie",
                            "il",
                            "in",
                            "is",
                            "it",
                            "jp",
                            "kr",
                            "kz",
                            "lt",
                            "lu",
                            "lv",
                            "ma",
                            "mt",
                            "mx",
                            "my",
                            "ng",
                            "ni",
                            "nl",
                            "no",
                            "nz",
                            "pa",
                            "pe",
                            "ph",
                            "pk",
                            "pl",
                            "pt",
                            "py",
                            "ro",
                            "ru",
                            "sa",
                            "se",
                            "sg",
                            "sk",
                            "sv",
                            "th",
                            "tr",
                            "tw",
                            "ua",
                            "us",
                            "uy",
                            "ve",
                            "vn",
                            "za"
                        ],
                        "type": "string",
                        "description": "Spotify chart market. `global` is the worldwide aggregate chart.",
                        "default": "global"
                    },
                    "period": {
                        "title": "Chart period (mode=spotifyChart)",
                        "enum": [
                            "daily",
                            "weekly"
                        ],
                        "type": "string",
                        "description": "Daily chart (updated daily) or weekly chart (Fri-Thu aggregate).",
                        "default": "daily"
                    },
                    "youtubeCategory": {
                        "title": "YouTube chart category",
                        "enum": [
                            "global",
                            "anglo",
                            "hispano",
                            "asian",
                            "other"
                        ],
                        "type": "string",
                        "description": "Kworb's regional split of today's most-viewed music videos on YouTube.",
                        "default": "global"
                    },
                    "chartCountry": {
                        "title": "Chart country (mode=shazamChart / deezerChart)",
                        "enum": [
                            "ae",
                            "ar",
                            "at",
                            "au",
                            "az",
                            "be",
                            "bg",
                            "bo",
                            "br",
                            "by",
                            "ca",
                            "ch",
                            "ci",
                            "cl",
                            "cm",
                            "cn",
                            "co",
                            "cr",
                            "cz",
                            "de",
                            "dk",
                            "dz",
                            "ec",
                            "ee",
                            "eg",
                            "es",
                            "fi",
                            "fr",
                            "gh",
                            "gr",
                            "gt",
                            "hn",
                            "hr",
                            "hu",
                            "id",
                            "ie",
                            "il",
                            "in",
                            "it",
                            "jm",
                            "jo",
                            "jp",
                            "ke",
                            "kr",
                            "kz",
                            "lb",
                            "lt",
                            "lv",
                            "ma",
                            "mx",
                            "my",
                            "mz",
                            "ng",
                            "nl",
                            "no",
                            "nz",
                            "pe",
                            "ph",
                            "pl",
                            "pt",
                            "py",
                            "ro",
                            "rs",
                            "ru",
                            "sa",
                            "se",
                            "sg",
                            "si",
                            "sk",
                            "sn",
                            "sv",
                            "th",
                            "tn",
                            "tr",
                            "tw",
                            "tz",
                            "ua",
                            "ug",
                            "uk",
                            "us",
                            "uy",
                            "uz",
                            "ve",
                            "vn",
                            "ww",
                            "za",
                            "zm"
                        ],
                        "type": "string",
                        "description": "Country market for the Shazam or Deezer chart. `ww` is Shazam's worldwide chart. Note: Deezer does not publish charts for every country Shazam does (unsupported combinations return no data).",
                        "default": "us"
                    },
                    "artistNames": {
                        "title": "Artist names (mode=artistStats)",
                        "type": "array",
                        "description": "One or more artist names to look up in Kworb's all-time Spotify artist directory (case-insensitive, exact match preferred), one per entry. A batch of names emits one `artistSummary` + song records per artist, up to the shared `maxItems` cap. Alternatively supply `spotifyArtistIds` directly.",
                        "default": [
                            "Taylor Swift"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "spotifyArtistIds": {
                        "title": "Spotify artist IDs (mode=artistStats)",
                        "type": "array",
                        "description": "One or more 22-character Spotify artist IDs, one per entry, e.g. `06HL4z0CvFAxyc27GXpf02` (Taylor Swift). Looked up directly (no directory search needed) and processed before `artistNames`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
