# Spotify New Music Friday by Country (`trovevault/spotify-new-music-friday-by-country`) Actor

Export the latest tracks from supported Spotify New Music Friday playlist pages with position, track, artist, album, release date, and Spotify URL.

- **URL**: https://apify.com/trovevault/spotify-new-music-friday-by-country.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** News, Social media, Other
- **Stats:** 2 total users, 1 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 New Music Friday by Country

Export current Spotify New Music Friday tracks by market, with playlist position, track name, artist, album, release date, and Spotify URL.

Use this Actor when you need a weekly, structured view of new releases across country, regional, and genre-specific New Music Friday playlists. Instead of opening each playlist manually, you can select the markets you care about and send the results directly to an Apify dataset, dashboard, spreadsheet, or music research workflow.

### What This Actor Helps You Decide

- Which artists and tracks are appearing in key New Music Friday markets.
- Whether a release is present in one market, several markets, or a regional editorial playlist.
- How releases are positioned inside each selected playlist.
- Which markets are useful to monitor for A&R, label marketing, playlist research, journalism, or weekly release discovery.

### What You Get

Each result row represents one track from one selected New Music Friday market.

The Actor returns:

- `market`: selected New Music Friday market.
- `position`: track position in that market's public playlist snapshot.
- `track`: track name.
- `artist`: artist names shown by Spotify.
- `album`: album, EP, or single title.
- `releaseDate`: public release date found in Spotify album metadata when available.
- `spotifyUrl`: direct Spotify track URL.

The output intentionally stays focused on track-level release intelligence. It does not add playlist names, discovery tags, or "new artist" labels.

### Use Cases

#### Artists And Managers

Track whether a new release appears in relevant editorial markets such as USA, Brazil, Portugal, United Kingdom, Germany, Japan, India, or regional playlists. Use the output to build weekly reporting around editorial visibility.

#### Labels And Marketing Teams

Compare new release placement across selected markets and feed the data into campaign dashboards. This is useful for launch-week monitoring, territory-level reporting, and checking which releases are surfacing in priority markets.

#### A&R And Music Research

Monitor fresh tracks by market to spot artists, collaborations, and genres showing up in New Music Friday lists. The structured dataset is easier to search, filter, and archive than a set of playlist pages.

#### Journalists And Playlist Researchers

Create a repeatable snapshot of current New Music Friday programming for market comparisons, release roundups, and weekly coverage.

### Supported Markets

The market dropdown is based on the public Super Friday Chart playlist list. It includes country markets such as USA, Brazil, Portugal, United Kingdom, Germany, France, Japan, India, Canada, and many more, plus regional or vertical playlists such as Latin America, K-Pop, Dance, Country, Gulf, Maghreb, Punjabi, World, and Christian.

There is no bulk "all markets" option. Select the exact markets you want to export. This keeps runs intentional and avoids noisy datasets.

Japan is mapped to New Music Friday only.

### 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 view, download, or connect the results.

Recommended starter input:

```json
{
  "markets": ["USA", "Brazil", "Portugal"]
}
````

To include Japan:

```json
{
  "markets": ["USA", "Brazil", "Portugal", "Japan"]
}
```

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `markets` | array of strings | Yes | New Music Friday markets to export. Choose one or more supported markets from the dropdown. |

### Output Example

Example item from a real validation run:

```json
{
  "market": "USA",
  "position": 1,
  "track": "Danceteria",
  "artist": "Madonna",
  "album": "CONFESSIONS II",
  "releaseDate": "2026-07-03",
  "spotifyUrl": "https://open.spotify.com/track/3a49TEtsbeAgzZAQH9WiDZ"
}
```

### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `market` | string | Selected New Music Friday market. |
| `position` | number | Position in the playlist snapshot returned by the public Spotify page. |
| `track` | string | Track title. |
| `artist` | string | Artist names shown by Spotify. |
| `album` | string | Album, EP, or single title. |
| `releaseDate` | string or null | Public release date from Spotify album metadata when available. |
| `spotifyUrl` | string | Direct Spotify track URL. |

### API Usage

Run the Actor synchronously and return dataset items:

```bash
curl "https://api.apify.com/v2/acts/trovevault~spotify-new-music-friday-by-country/run-sync-get-dataset-items" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -d '{"markets":["USA","Brazil","Portugal"]}'
```

Run a smaller smoke test:

```bash
curl "https://api.apify.com/v2/acts/trovevault~spotify-new-music-friday-by-country/run-sync-get-dataset-items" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -d '{"markets":["USA"]}'
```

### Working With Results

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

- weekly label reports,
- A\&R discovery spreadsheets,
- artist campaign dashboards,
- editorial playlist monitoring,
- market-by-market release comparison.

You can also use the dataset from Apify integrations, API clients, or MCP-compatible workflows that read Apify datasets.

### Limitations

- The Actor reads public Spotify playlist and album pages.
- Some public playlist pages expose a limited embedded track set. The Actor exports the tracks available in the public page payload.
- Release dates depend on public album metadata. If Spotify does not expose a release date for a track's album page, `releaseDate` may be `null`.
- The Actor exports the current public playlist snapshot. It does not provide historical playlist archives by itself.
- Market availability follows the supported playlist list and may change over time.
- The Actor does not require or use a Spotify login.

### Troubleshooting

#### The run returns fewer tracks than expected

Some public playlist pages expose fewer embedded tracks than the full playlist UI. The Actor returns the rows available in the public page payload.

#### A market is missing from the dropdown

Only verified supported markets are included. If a playlist changes, the mapping may need to be updated before that market can be offered reliably.

#### `releaseDate` is null

The Actor enriches release dates from public album metadata. If that metadata is unavailable, the field remains `null` instead of guessing.

#### I need all markets at once

This Actor intentionally does not include an all-markets option. Run selected market groups separately to keep datasets smaller and easier to inspect.

### FAQ

#### Does this require a Spotify account?

No. The Actor uses public Spotify playlist and album pages.

#### Does it output playlist names?

No. The output is intentionally track-focused: market, position, track, artist, album, release date, and Spotify URL.

#### Can I use it for historical New Music Friday tracking?

The Actor exports the current public playlist snapshot. For history, schedule the Actor weekly and store each run's dataset.

#### Can this feed a dashboard?

Yes. Export the dataset or read it through the Apify API. The stable field names make it straightforward to load into BI tools, spreadsheets, or internal reporting.

### Related Actor

Use `Spotify Top 200 Charts` when you need current Spotify chart positions, daily streams, seven-day streams, and total streams by market.

### Changelog

- `0.1`: Initial private release with supported New Music Friday markets, Japan Friday mapping, and release date enrichment.

# Actor input Schema

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

Markets to export. Select one or more supported New Music Friday playlists.

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

Optional existing Apify dataset ID. When provided, playlist 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": [
    "USA",
    "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": [
        "USA",
        "Brazil",
        "Portugal"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/spotify-new-music-friday-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": [
        "USA",
        "Brazil",
        "Portugal",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("trovevault/spotify-new-music-friday-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": [
    "USA",
    "Brazil",
    "Portugal"
  ]
}' |
apify call trovevault/spotify-new-music-friday-by-country --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify New Music Friday by Country",
        "description": "Export the latest tracks from supported Spotify New Music Friday playlist pages with position, track, artist, album, release date, and Spotify URL.",
        "version": "0.1",
        "x-build-id": "RhQabXtdRLV0RATKJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~spotify-new-music-friday-by-country/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-spotify-new-music-friday-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-new-music-friday-by-country/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-spotify-new-music-friday-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-new-music-friday-by-country/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-spotify-new-music-friday-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": "Markets to export. Select one or more supported New Music Friday playlists.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "USA",
                                "Brazil",
                                "Mexico",
                                "United Kingdom",
                                "Germany",
                                "Latin America",
                                "Philippines",
                                "Latin",
                                "Canada",
                                "Dance",
                                "Punjabi",
                                "World",
                                "Australia / New Zealand",
                                "France",
                                "Spain",
                                "Country",
                                "Argentina",
                                "Religiosas",
                                "Christian",
                                "India",
                                "Italy",
                                "K-Pop",
                                "Turkey",
                                "Netherlands",
                                "Japan",
                                "Indonesia",
                                "Sweden",
                                "Norway",
                                "Nigeria",
                                "South Africa",
                                "Colombia",
                                "Denmark",
                                "Taiwan",
                                "Poland",
                                "Finland",
                                "Hindi",
                                "Portugal",
                                "Thailand",
                                "Malaysia",
                                "Peru",
                                "Egypt",
                                "Maghreb",
                                "Switzerland",
                                "Greece",
                                "Belgium",
                                "Hong Kong",
                                "Gulf",
                                "Canada (FR)",
                                "Singapore",
                                "Pakistan",
                                "Ukraine",
                                "Czech Republic & Slovakia",
                                "Vietnam",
                                "Kenya",
                                "Korea",
                                "Romania",
                                "Ghana",
                                "Hungary",
                                "Bangladesh",
                                "Sri Lanka",
                                "Iceland",
                                "Levant",
                                "Saudi Arabia"
                            ]
                        },
                        "default": [
                            "USA"
                        ]
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID. When provided, playlist 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
