# Shazam Charts Scraper (`solidcode/shazam-charts-scraper`) Actor

\[💰 $0.99 / 1K] Extract trending tracks from Shazam charts — global Top 200, country, city, and genre charts. Get rank, title, artist, album, cover art, genre, ISRC, release date, and Apple Music links. Track what the world is discovering in music.

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

## Pricing

from $0.99 / 1,000 results

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

## Shazam Charts Scraper

Pull trending tracks straight from Shazam's charts at scale — chart rank, title, artist, album, genre, ISRC recording codes, 600×600 cover art, Apple Music and Shazam links, and release dates for every song people are discovering right now. Coverage spans the Global Top 200, 69 country charts, 168 city charts, and 17 genre charts, in both most-Shazamed and viral/rising flavors. Built for A&R scouts, playlist curators, and music-data analysts who need to catch breakout songs early — market by market — without checking hundreds of chart pages by hand.

### Why This Scraper?

- **70 markets of country coverage** — the Global (World) chart plus 69 individual country charts spanning six continents, from the United States, Japan, and Germany to Brazil, Nigeria, Kenya, Kazakhstan, and the United Arab Emirates — including deep African and Eastern-European markets most chart tools skip. Pull one market or all of them in a single run.
- **168 city-level charts** — see what's trending block by block in London, New York City, Tokyo, São Paulo, and 160-plus more cities, so you can spot a track breaking in one metro before it goes national.
- **17 genre charts** — Pop, Hip-Hop / Rap, Dance, Electronic, House, Rock, Alternative, Latin, R&B / Soul, Country, K-Pop, Afrobeats, French Pop, Reggae / Dancehall, Singer-Songwriter, Film TV & Stage, and Worldwide.
- **Top Tracks and Viral / Rising in one actor** — collect the most-Shazamed chart or the fast-rising viral chart with a single dropdown; viral surfaces songs on the way up before they peak.
- **ISRC recording code on every track** — the industry-standard identifier that lets you join Shazam discovery data directly to your own catalog, licensing system, or royalty database with no fuzzy title matching.
- **Apple Music and Shazam links per track** — a ready-to-open Apple Music URL and a Shazam song URL for every row, so listening or verifying a discovery is one click away.
- **Global Top 200 depth** — country and world Top charts run a full 200 positions deep, far past the front-page top 10, so you catch songs still climbing the ranking.
- **Localized text in 12 languages** — return track and artist text in English, Spanish, French, German, Italian, Portuguese, Japanese, Korean, Chinese, Russian, Arabic, or Turkish.
- **600×600 cover art URLs** — full-resolution artwork for every track, ready to drop into dashboards, pitch decks, or playlist thumbnails.

### Use Cases

**A&R & Talent Scouting**
- Spot breakout artists the moment they enter a country or city chart
- Compare a new signing's traction across 70 markets at once
- Track viral / rising charts to catch songs before they peak
- Surface genre-specific talent with the 17 focused genre charts

**Playlist Curation**
- Build "trending now" playlists per country or city with live rankings
- Refresh editorial playlists from the daily most-Shazamed chart
- Match playlist themes to genre charts like K-Pop, Afrobeats, or Latin
- Source cover art and Apple Music links for every track in one pass

**Music Market Research**
- Map how a song ranks across 69 countries side by side
- Benchmark a release against the Global Top 200
- Study regional taste differences down to 168 individual cities
- Feed chart movement into trend dashboards and label reports

**Licensing & Rights**
- Join Shazam discovery data to your catalog on the ISRC code
- Pull release dates and album context for clearance workflows
- Identify high-demand tracks by market for sync and licensing pitches

**Trend Forecasting**
- Watch viral charts to model which songs will chart nationally next
- Track a track's climb up the ranking day over day
- Detect genre momentum shifts across cities and countries

### Getting Started

#### Global Top 200 (simplest)

Leave everything on defaults to pull the worldwide most-Shazamed chart:

```json
{
    "chartType": "top",
    "countries": ["world"]
}
````

#### Country charts by genre

Pull the Pop and Hip-Hop / Rap charts for the United States and the United Kingdom:

```json
{
    "chartType": "top",
    "countries": ["US", "GB"],
    "genres": ["pop", "hip-hop-rap"],
    "maxTracksPerChart": 100
}
```

#### Viral / rising across markets

Track the fast-rising chart for several countries and the world:

```json
{
    "chartType": "viral",
    "countries": ["world", "US", "BR", "NG"],
    "maxTracksPerChart": 50
}
```

#### Full multi-market example

Combine countries, cities, and genres, localized in Spanish:

```json
{
    "chartType": "top",
    "countries": ["ES", "MX", "AR"],
    "cities": ["Madrid", "Mexico City", "Buenos Aires"],
    "genres": ["latin", "pop"],
    "maxTracksPerChart": 0,
    "language": "es"
}
```

### Input Reference

#### Charts

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `chartType` | select | `Top Tracks` | Which chart to pull: **Top Tracks (most Shazamed)** or **Viral / Rising Tracks**. |
| `countries` | array | `["Global (World)"]` | One or more country charts, or **Global (World)** for the worldwide chart. Leave empty to default to Global. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `cities` | array | `[]` | Optional city-level charts by name (e.g. "London", "New York City", "Tokyo"). Names are matched against the 168 cities Shazam publishes; a name with no match is skipped with a note. |
| `genres` | array | `[]` | Optional genre charts. When set, a genre chart is collected for each selected country + genre. Each country offers a subset of genres; combinations a country doesn't publish are skipped automatically. Leave empty for the all-genres chart. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxTracksPerChart` | integer | `200` | Maximum tracks per chart, counted from the top down. Set to `0` to collect every available track. Top charts run to ~200; viral and genre charts are shorter. |
| `language` | select | `English` | Language for track and artist text where Shazam provides localized values. Choose from 12 languages including Spanish, French, German, Japanese, Korean, Chinese, Russian, Arabic, and Turkish. |

### Output

Each row is one track on one chart. Here's a representative result:

```json
{
    "rank": 1,
    "title": "Espresso",
    "artist": "Sabrina Carpenter",
    "album": "Short n' Sweet",
    "genre": "Pop",
    "isrc": "USUG12403188",
    "coverArt": "https://is1-ssl.mzstatic.com/image/thumb/example/600x600bb.jpg",
    "appleMusicUrl": "https://music.apple.com/us/album/espresso/1739816043",
    "shazamUrl": "https://www.shazam.com/song/739648464",
    "shazamId": "739648464",
    "releaseDate": "2024-04-11",
    "chartType": "top",
    "chartCountry": "world",
    "chartCity": null,
    "chartGenre": null,
    "chartUrl": "https://www.shazam.com/charts/top-200/world",
    "scrapedAt": "2026-07-01T14:30:00Z"
}
```

#### Track Fields

| Field | Type | Description |
|-------|------|-------------|
| `rank` | number | Chart position, 1 = top of the chart |
| `title` | string | Track title |
| `artist` | string | Primary artist name |
| `album` | string | Album the track appears on |
| `genre` | string | Track genre (e.g. Pop, Hip-Hop / Rap) |
| `releaseDate` | string | Track release date |
| `coverArt` | string | 600×600 cover artwork URL |

#### Identifiers & Links

| Field | Type | Description |
|-------|------|-------------|
| `isrc` | string | ISRC recording code — join key to catalog and licensing systems |
| `appleMusicUrl` | string | Direct Apple Music track URL |
| `shazamUrl` | string | Shazam song page URL |
| `shazamId` | string | Shazam track identifier |

#### Chart Context

| Field | Type | Description |
|-------|------|-------------|
| `chartType` | string | `top` or `viral` |
| `chartCountry` | string | Country code of the chart (or `world`) |
| `chartCity` | string | City name for city charts, otherwise null |
| `chartGenre` | string | Genre slug for genre charts, otherwise null |
| `chartUrl` | string | Source chart page URL |
| `scrapedAt` | string | ISO timestamp of collection |

### Tips for Best Results

- **Start with a single chart** — run the Global Top 200 first to confirm the data fits your needs, then scale up to more countries, cities, and genres.
- **Viral is country- and world-level only** — the viral / rising chart exists for whole countries and the Global chart, not per city or per genre. If you add a city or genre with the viral chart type, that combination is collected as Top Tracks instead.
- **Genres vary by country** — each country publishes only a subset of the 17 genres; the Global (World) chart offers all of them. Unsupported country + genre combinations are skipped automatically, so you can request broadly without errors.
- **Use ISRC as your join key** — match Shazam discovery data to your own catalog, royalty, or licensing database on the ISRC code instead of fuzzy title-and-artist matching.
- **Set `maxTracksPerChart` to control cost** — the top of the chart is where breakout signals live. Cap at 50–100 to focus on climbers, or set `0` to pull every position.
- **Localize for local markets** — match the `language` to the market you're studying (e.g. Japanese for Japan, Portuguese for Brazil) so track and artist text reads naturally.
- **Add cities to catch songs early** — a track often breaks in one metro before it charts nationally, so the 168 city charts are your earliest signal for A\&R and forecasting.

### Pricing

**From $0.99 per 1,000 results** — one flat rate per track returned, cheaper than checking hundreds of chart pages by hand. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.118 | $0.110 | $0.105 | $0.099 |
| 1,000 | $1.18 | $1.10 | $1.05 | $0.99 |
| 10,000 | $11.80 | $11.00 | $10.50 | $9.90 |
| 100,000 | $118.00 | $110.00 | $105.00 | $99.00 |

A "result" is one track row in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee** of $0.01.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom workflows on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate music industry research, playlist curation, market analysis, and A\&R work. Users are responsible for complying with applicable laws and the terms of service of the platforms involved. Use collected chart data responsibly and respect the rights of artists and rights holders.

# Actor input Schema

## `chartType` (type: `string`):

Which Shazam chart to pull. 'Top Tracks' is the standard most-Shazamed chart. 'Viral / Rising' surfaces fast-rising tracks — note Viral charts exist for whole countries and the Global (World) chart only, not for cities or genres, so any city or genre you add is collected as a Top Tracks chart.

## `countries` (type: `array`):

Country charts to collect. Choose one or more countries, or pick 'Global (World)' for the worldwide chart. Leave empty to default to the Global chart.

## `cities` (type: `array`):

Optional city-level charts (e.g. 'London', 'New York City', 'Tokyo'). City charts show what is trending locally. City names are matched against the cities Shazam publishes (168 cities across the supported countries) — a name with no matching city chart is skipped with a note. Leave empty to skip city charts.

## `genres` (type: `array`):

Optional genre filter. When set, a genre chart is collected for each selected country + genre (e.g. United States + Pop). Note: each country only offers a subset of these genres — combinations a country doesn't publish are skipped automatically. For the Global (World) chart, all genres below are available. Leave empty to collect the all-genres chart. Genre charts apply to Top Tracks only (Viral is country/world-wide only).

## `maxTracksPerChart` (type: `integer`):

Maximum number of tracks to collect from each chart, counted from the top of the ranking down. Shazam Top charts cap at around 200 tracks; Viral and genre charts are shorter (around 25-100). Set to 0 to collect every available track in each chart. You pay per track returned.

## `language` (type: `string`):

Language for track and artist text where Shazam provides localized values.

## Actor input object example

```json
{
  "chartType": "top",
  "countries": [
    "world"
  ],
  "cities": [],
  "genres": [],
  "maxTracksPerChart": 200,
  "language": "en"
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of chart tracks with rank, title, artist, genre, chart context, and links.

# 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 = {
    "chartType": "top",
    "countries": [
        "world"
    ],
    "cities": [],
    "genres": [],
    "maxTracksPerChart": 200,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/shazam-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 = {
    "chartType": "top",
    "countries": ["world"],
    "cities": [],
    "genres": [],
    "maxTracksPerChart": 200,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/shazam-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 '{
  "chartType": "top",
  "countries": [
    "world"
  ],
  "cities": [],
  "genres": [],
  "maxTracksPerChart": 200,
  "language": "en"
}' |
apify call solidcode/shazam-charts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shazam Charts Scraper",
        "description": "[💰 $0.99 / 1K] Extract trending tracks from Shazam charts — global Top 200, country, city, and genre charts. Get rank, title, artist, album, cover art, genre, ISRC, release date, and Apple Music links. Track what the world is discovering in music.",
        "version": "1.0",
        "x-build-id": "j3ZaHucO8LZhCyoAe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~shazam-charts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-shazam-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/solidcode~shazam-charts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-shazam-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/solidcode~shazam-charts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-shazam-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",
                "properties": {
                    "chartType": {
                        "title": "Chart Type",
                        "enum": [
                            "top",
                            "viral"
                        ],
                        "type": "string",
                        "description": "Which Shazam chart to pull. 'Top Tracks' is the standard most-Shazamed chart. 'Viral / Rising' surfaces fast-rising tracks — note Viral charts exist for whole countries and the Global (World) chart only, not for cities or genres, so any city or genre you add is collected as a Top Tracks chart."
                    },
                    "countries": {
                        "title": "Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Country charts to collect. Choose one or more countries, or pick 'Global (World)' for the worldwide chart. Leave empty to default to the Global chart.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "world",
                                "US",
                                "GB",
                                "CA",
                                "AU",
                                "NZ",
                                "IE",
                                "FR",
                                "DE",
                                "ES",
                                "IT",
                                "NL",
                                "BE",
                                "PT",
                                "CH",
                                "AT",
                                "SE",
                                "NO",
                                "DK",
                                "FI",
                                "PL",
                                "GR",
                                "CZ",
                                "HU",
                                "RO",
                                "HR",
                                "BG",
                                "UA",
                                "BY",
                                "RU",
                                "AZ",
                                "KZ",
                                "UZ",
                                "JP",
                                "KR",
                                "CN",
                                "SG",
                                "MY",
                                "TH",
                                "ID",
                                "PH",
                                "VN",
                                "IN",
                                "BR",
                                "MX",
                                "AR",
                                "CL",
                                "CO",
                                "PE",
                                "UY",
                                "VE",
                                "CR",
                                "AE",
                                "SA",
                                "IL",
                                "EG",
                                "DZ",
                                "MA",
                                "TN",
                                "ZA",
                                "NG",
                                "GH",
                                "KE",
                                "CI",
                                "SN",
                                "CM",
                                "TZ",
                                "UG",
                                "MZ",
                                "ZM"
                            ],
                            "enumTitles": [
                                "Global (World)",
                                "United States",
                                "United Kingdom",
                                "Canada",
                                "Australia",
                                "New Zealand",
                                "Ireland",
                                "France",
                                "Germany",
                                "Spain",
                                "Italy",
                                "Netherlands",
                                "Belgium",
                                "Portugal",
                                "Switzerland",
                                "Austria",
                                "Sweden",
                                "Norway",
                                "Denmark",
                                "Finland",
                                "Poland",
                                "Greece",
                                "Czechia",
                                "Hungary",
                                "Romania",
                                "Croatia",
                                "Bulgaria",
                                "Ukraine",
                                "Belarus",
                                "Russia",
                                "Azerbaijan",
                                "Kazakhstan",
                                "Uzbekistan",
                                "Japan",
                                "South Korea",
                                "China",
                                "Singapore",
                                "Malaysia",
                                "Thailand",
                                "Indonesia",
                                "Philippines",
                                "Vietnam",
                                "India",
                                "Brazil",
                                "Mexico",
                                "Argentina",
                                "Chile",
                                "Colombia",
                                "Peru",
                                "Uruguay",
                                "Venezuela",
                                "Costa Rica",
                                "United Arab Emirates",
                                "Saudi Arabia",
                                "Israel",
                                "Egypt",
                                "Algeria",
                                "Morocco",
                                "Tunisia",
                                "South Africa",
                                "Nigeria",
                                "Ghana",
                                "Kenya",
                                "Ivory Coast",
                                "Senegal",
                                "Cameroon",
                                "Tanzania",
                                "Uganda",
                                "Mozambique",
                                "Zambia"
                            ]
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Optional city-level charts (e.g. 'London', 'New York City', 'Tokyo'). City charts show what is trending locally. City names are matched against the cities Shazam publishes (168 cities across the supported countries) — a name with no matching city chart is skipped with a note. Leave empty to skip city charts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "genres": {
                        "title": "Genres",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional genre filter. When set, a genre chart is collected for each selected country + genre (e.g. United States + Pop). Note: each country only offers a subset of these genres — combinations a country doesn't publish are skipped automatically. For the Global (World) chart, all genres below are available. Leave empty to collect the all-genres chart. Genre charts apply to Top Tracks only (Viral is country/world-wide only).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "pop",
                                "hip-hop-rap",
                                "dance",
                                "electronic",
                                "house",
                                "rock",
                                "alternative",
                                "latin",
                                "randb-soul",
                                "country",
                                "k-pop",
                                "afrobeats",
                                "french-pop",
                                "reggae-dancehall",
                                "singer-songwriter",
                                "film-tv-and-stage",
                                "worldwide"
                            ],
                            "enumTitles": [
                                "Pop",
                                "Hip-Hop / Rap",
                                "Dance",
                                "Electronic",
                                "House",
                                "Rock",
                                "Alternative",
                                "Latin",
                                "R&B / Soul",
                                "Country",
                                "K-Pop",
                                "Afrobeats",
                                "French Pop",
                                "Reggae / Dancehall",
                                "Singer-Songwriter",
                                "Film, TV & Stage",
                                "Worldwide"
                            ]
                        }
                    },
                    "maxTracksPerChart": {
                        "title": "Max Tracks Per Chart",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of tracks to collect from each chart, counted from the top of the ranking down. Shazam Top charts cap at around 200 tracks; Viral and genre charts are shorter (around 25-100). Set to 0 to collect every available track in each chart. You pay per track returned.",
                        "default": 200
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "ja",
                            "ko",
                            "zh-CN",
                            "ru",
                            "ar",
                            "tr"
                        ],
                        "type": "string",
                        "description": "Language for track and artist text where Shazam provides localized values."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
