# Spotify Daily Top 200 Charts by Country (`trovevault/spotify-daily-top-200-charts-by-country`) Actor

Export available Spotify Top 200 chart rows by market with rank, movement, streams, seven-day streams, totals, and Spotify track URLs.

- **URL**: https://apify.com/trovevault/spotify-daily-top-200-charts-by-country.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** News, Social media, Other
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 songs

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

## Spotify Top 200 Charts

Export current Spotify Top 200 daily chart rows by market, including rank, movement, daily streams, seven-day streams, total streams, days on chart, peak rank, artist, track, and Spotify URL.

Use this Actor when you need structured chart intelligence across Spotify markets without manually checking each chart table. It is built for daily market monitoring, artist benchmarking, campaign reporting, and music data workflows that need clean rows instead of screenshots or manual copy-paste.

### What This Actor Helps You Decide

- Which tracks are currently ranking in selected Spotify Top 200 markets.
- How much daily streaming volume a ranked track is receiving.
- Whether a track is moving up, holding position, or losing momentum.
- How performance differs across Global, country, and regional markets.
- Which tracks have strong chart longevity, peak rank, or total stream accumulation.

### What You Get

Each result row represents one ranked track in one selected market.

The Actor returns:

- `market`: selected chart market.
- `rank`: current chart position.
- `change`: rank movement shown by the chart table.
- `artist`: artist name.
- `track`: track title.
- `dailyStreams`: streams for the current daily chart period.
- `dailyStreamsChange`: movement in daily streams.
- `sevenDayStreams`: rolling seven-day stream total.
- `sevenDayStreamsChange`: movement in seven-day streams.
- `totalStreams`: total streams shown for the track.
- `daysOnChart`: number of days the track has appeared on the chart.
- `peakRank`: best rank shown in the chart table.
- `spotifyUrl`: direct Spotify track URL.

### Use Cases

#### Artists And Managers

Track chart rank, daily streams, peak position, and days on chart in priority markets. Use the output to build daily updates for campaigns, release performance, and territory-level reporting.

#### Labels And A&R Teams

Compare songs across markets to spot breakout tracks, regional lift, and cross-market momentum. The dataset is structured for spreadsheets, dashboards, and internal reports.

#### Music Marketers

Monitor campaign impact by checking whether daily streams and rank movement are improving after playlisting, social campaigns, PR, or paid media activity.

#### Journalists And Analysts

Export current chart data for music business coverage, market comparisons, trend pieces, and weekly analysis.

#### Royalty Buyers And Music Investors

Use chart longevity, daily streams, total streams, and market coverage as supporting signals when screening catalog performance.

### Supported Markets

The dropdown includes Global and many country markets, including United States, Brazil, Portugal, United Kingdom, Germany, France, Spain, Italy, Japan, South Korea, India, Mexico, Argentina, Colombia, Netherlands, Sweden, and more.

Use `All markets` when you want every supported chart market in one run. For faster tests and cleaner datasets, select only the markets you need.

### How To Use

1. Open the Actor on Apify.
2. Choose one or more markets from the `markets` dropdown.
3. Run the Actor.
4. Open the dataset to inspect, export, or connect the results.

Recommended starter input:

```json
{
  "markets": ["Global", "United States", "Brazil", "Portugal"]
}
````

Small API or smoke-test input:

```json
{
  "markets": ["Global", "Brazil"]
}
```

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `markets` | array of strings | Yes | Spotify chart markets to export. Choose specific markets or `All markets`. |

The Actor intentionally does not accept a `date` field. It exports the current available daily chart.

### Output Example

Example item from a real validation run:

```json
{
  "market": "Global",
  "rank": 1,
  "change": 0,
  "artist": "Shakira",
  "track": "Dai Dai",
  "dailyStreams": 4745266,
  "dailyStreamsChange": 141486,
  "sevenDayStreams": 30137900,
  "sevenDayStreamsChange": 222532,
  "totalStreams": 133138570,
  "daysOnChart": 45,
  "peakRank": 1,
  "spotifyUrl": "https://open.spotify.com/track/0kosUz0jePvjiz4ctmR6wL"
}
```

### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `market` | string | Selected Spotify chart market. |
| `rank` | number | Current chart rank. |
| `change` | number or null | Rank movement. `0` means no movement; `null` can represent a new entry when the chart table does not provide a numeric change. |
| `artist` | string | Artist name from the chart row. |
| `track` | string | Track title from the chart row. |
| `dailyStreams` | number or null | Streams for the current daily chart period. |
| `dailyStreamsChange` | number or null | Change in daily streams. |
| `sevenDayStreams` | number or null | Rolling seven-day streams. |
| `sevenDayStreamsChange` | number or null | Change in rolling seven-day streams. |
| `totalStreams` | number or null | Total streams shown by the chart table. |
| `daysOnChart` | number or null | Number of days the track has charted. |
| `peakRank` | number or null | Best rank shown for the track. |
| `spotifyUrl` | string or null | Direct Spotify track URL when available. |

### API Usage

Run the Actor synchronously and return dataset items:

```bash
curl "https://api.apify.com/v2/acts/trovevault~spotify-top-200-charts/run-sync-get-dataset-items" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -d '{"markets":["Global","Brazil"]}'
```

Run a single-market test:

```bash
curl "https://api.apify.com/v2/acts/trovevault~spotify-top-200-charts/run-sync-get-dataset-items" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -d '{"markets":["Portugal"]}'
```

### Working With Results

The default dataset can be exported from Apify as JSON, CSV, Excel, XML, or RSS. Typical workflows include:

- daily chart monitoring dashboards,
- artist or label performance reports,
- market-by-market release benchmarking,
- A\&R discovery and trend tracking,
- music business research,
- catalog performance screening.

You can also read the dataset with the Apify API, Apify client libraries, integrations, or MCP-compatible workflows that consume Apify datasets.

### Limitations

- The Actor exports the current available daily chart only.
- Historical dates are not accepted.
- Some markets may return fewer than 200 rows when the public chart table contains fewer available entries.
- Stream counts are the values shown in the current public chart table. They should be treated as chart reporting figures, not a full royalty accounting export.
- `dailyStreams` means streams for the current daily chart period.
- A new entry can have `change: null` if no numeric previous-position movement is available.

### Troubleshooting

#### A market returns fewer than 200 rows

Some public chart tables expose fewer available rows for a market. The Actor returns the rows that are present and parseable.

#### I cannot request a historical date

That is expected. This Actor is scoped as a current daily chart exporter. To build history, schedule the Actor daily and store each run.

#### I see `null` in a movement field

Movement fields can be `null` when the chart row represents a new entry or when the public table does not provide a numeric value.

#### The dataset is very large with `All markets`

Use selected markets for normal monitoring. `All markets` is best for broad snapshots and periodic research exports.

### FAQ

#### Is `dailyStreams` the daily stream count?

Yes. `dailyStreams` is the stream count for the current daily chart period shown in the chart table.

#### Does the Actor include a `date` field?

No. It exports the current daily chart and does not include date in the input or output.

#### Can this monitor charts over time?

Yes, by scheduling the Actor daily in Apify and storing each dataset. The Actor itself returns the current chart snapshot for each run.

#### Can I use this in dashboards?

Yes. The output uses stable field names and numeric stream fields, making it suitable for BI tools, spreadsheets, and internal data pipelines.

### Related Actor

Use `Spotify New Music Friday by Country` when you need current New Music Friday release rows by selected market.

### Changelog

- `0.1`: Initial private release with current daily Top 200 market exports and `dailyStreams` naming.

# Actor input Schema

## `markets` (type: `array`):

Spotify chart markets to export. Choose All markets to fetch every supported market.

## `datasetId` (type: `string`):

Optional existing Apify dataset ID. When provided, chart rows are appended there in addition to the default run dataset.

## `runId` (type: `string`):

Optional external run or workflow ID to include in the run summary for pipeline tracking.

## Actor input object example

```json
{
  "markets": [
    "Global",
    "United States",
    "Brazil",
    "Portugal"
  ]
}
```

# Actor output Schema

## `datasetUrl` (type: `string`):

No description

# 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 = {
    "markets": [
        "Global",
        "United States",
        "Brazil",
        "Portugal"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/spotify-daily-top-200-charts-by-country").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 = { "markets": [
        "Global",
        "United States",
        "Brazil",
        "Portugal",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("trovevault/spotify-daily-top-200-charts-by-country").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 '{
  "markets": [
    "Global",
    "United States",
    "Brazil",
    "Portugal"
  ]
}' |
apify call trovevault/spotify-daily-top-200-charts-by-country --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/spotify-daily-top-200-charts-by-country",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Daily Top 200 Charts by Country",
        "description": "Export available Spotify Top 200 chart rows by market with rank, movement, streams, seven-day streams, totals, and Spotify track URLs.",
        "version": "0.1",
        "x-build-id": "mDkLGDHrJlDRNWSHm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~spotify-daily-top-200-charts-by-country/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-spotify-daily-top-200-charts-by-country",
                "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/trovevault~spotify-daily-top-200-charts-by-country/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-spotify-daily-top-200-charts-by-country",
                "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/trovevault~spotify-daily-top-200-charts-by-country/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-spotify-daily-top-200-charts-by-country",
                "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": [
                    "markets"
                ],
                "properties": {
                    "markets": {
                        "title": "Markets",
                        "type": "array",
                        "description": "Spotify chart markets to export. Choose All markets to fetch every supported market.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "All markets",
                                "Global",
                                "Argentina",
                                "Australia",
                                "Austria",
                                "Belgium",
                                "Bolivia",
                                "Brazil",
                                "Bulgaria",
                                "Canada",
                                "Chile",
                                "Colombia",
                                "Costa Rica",
                                "Czech Republic",
                                "Denmark",
                                "Dominican Republic",
                                "Ecuador",
                                "Egypt",
                                "El Salvador",
                                "Estonia",
                                "Finland",
                                "France",
                                "Germany",
                                "Greece",
                                "Guatemala",
                                "Honduras",
                                "Hong Kong",
                                "Hungary",
                                "Iceland",
                                "India",
                                "Indonesia",
                                "Ireland",
                                "Israel",
                                "Italy",
                                "Japan",
                                "Kazakhstan",
                                "Latvia",
                                "Lithuania",
                                "Luxembourg",
                                "Malaysia",
                                "Mexico",
                                "Morocco",
                                "Netherlands",
                                "New Zealand",
                                "Nicaragua",
                                "Nigeria",
                                "Norway",
                                "Pakistan",
                                "Panama",
                                "Paraguay",
                                "Peru",
                                "Philippines",
                                "Poland",
                                "Portugal",
                                "Romania",
                                "Saudi Arabia",
                                "Singapore",
                                "Slovakia",
                                "South Africa",
                                "South Korea",
                                "Spain",
                                "Sweden",
                                "Switzerland",
                                "Taiwan",
                                "Thailand",
                                "Turkey",
                                "Ukraine",
                                "United Arab Emirates",
                                "United Kingdom",
                                "United States",
                                "Uruguay",
                                "Venezuela",
                                "Vietnam"
                            ]
                        },
                        "default": [
                            "Global"
                        ]
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID. When provided, chart rows are appended there in addition to the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID",
                        "type": "string",
                        "description": "Optional external run or workflow ID to include in the run summary for pipeline tracking."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
