# Spotify Monthly Listener Scraper (`data_wiki/spotify-monthly-listener`) Actor

See any Spotify artist's monthly listeners, followers, world rank, top cities, top tracks with play counts, tour dates and bio. No Spotify login or API key needed. Great for tracking artist growth, scouting talent and music industry research.

- **URL**: https://apify.com/data_wiki/spotify-monthly-listener.md
- **Developed by:** [Data WiKi](https://apify.com/data_wiki) (community)
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### 🚀 What is Spotify Monthly Listener Scraper?

Spotify Monthly Listener Scraper is an Apify Actor that works as a Spotify monthly listeners scraper for public artist pages. Add artist links, IDs or names and it returns monthly listeners, followers, world rank, top cities, top tracks with play counts and tour dates as rows, with no Spotify login or API key.

- **Audience numbers in one row:** monthly listeners, followers, world rank and followers per monthly listener for every artist you list.
- **Cities, tracks and tour dates:** the top cities, the top tracks with play counts and the upcoming concerts of each artist.
- **Optional extras:** the newest releases with a play count for every track, or the artists fans also like.
- **Rows arrive while the run is going:** each artist is saved as soon as it is collected, and eight extra tables split the nested lists into one row per item.
- **Nothing to install:** run it online in Apify Console, by API or on a schedule, and export JSON, CSV, Excel, XML or HTML.

Click **Try for free**, paste an artist link and press **Start**.

Spotify Monthly Listener Scraper is an independent tool. It is not affiliated with or endorsed by Spotify, and Spotify is a trademark of its owner.

### 📊 What data can you extract from Spotify?

Each run returns a Spotify artist dataset with one row per artist, which you can export as JSON, CSV, Excel, XML or HTML. Values Spotify does not show for an artist stay `null`. The example values below are made up and only show the shape of the data.

| Field | Description | Example |
|---|---|---|
| `artist_id`, `artist_name` | Spotify artist ID and the artist name | `ExampleArtistId0000001`, `Example Artist` |
| `url` | Link to the artist page | `https://open.spotify.com/artist/ExampleArtistId0000001` |
| `verified` | Whether the artist has the verified badge | `true` |
| `monthly_listeners` | The monthly listeners figure shown on the artist page | `1250000` |
| `followers` | Number of followers | `480000` |
| `world_rank` | Position in Spotify world rankings by monthly listeners; `null` when unranked | `2150` |
| `followers_per_monthly_listener` | Followers divided by monthly listeners | `0.384` |
| `top_cities`, `top_city` | Spotify artist top cities with city, country, region, listeners and the share of monthly listeners in percent, plus the first city | `London`, `5.0` |
| `top_tracks`, `top_tracks_total_plays` | Most played tracks with play counts, duration and link, plus the sum of those play counts | `13100000` |
| `album_count`, `single_count`, `compilation_count` | Number of albums, singles and EPs, and compilations | `4`, `12`, `1` |
| `latest_release`, `days_since_latest_release` | Newest release (name, type, date, link) and the days since it came out | `56` |
| `social_links`, `biography` | Social profile links keyed by network name, and the Spotify artist biography as plain text | `{ "instagram": "https://..." }` |
| `avatar_image`, `header_image`, `gallery` | Profile picture, header picture and gallery picture links | `https://example.com/avatar.jpg` |
| `upcoming_concerts`, `upcoming_concerts_total` | Upcoming tour dates (title, date, venue, city, festival, link) and their number | `1` |
| `playlists_by_artist`, `featured_in_playlists`, `discovered_on`, `discovered_on_total` | Playlists made by the artist, playlists featuring the artist, playlists where listeners discover the artist, and the total Spotify reports | `1` |
| `appears_on`, `appears_on_total` | Releases of other artists that feature this artist, and the total Spotify reports | `1` |
| `related_artists` | Artists fans also like: ID, name, link and monthly listeners when that artist was also collected | `Example Neighbor` |
| `crawl_depth`, `found_via` | `0` for artists you listed, `1` or more for similar artists, and the artist ID they were found through | `0`, `null` |
| `releases` | Newest releases with tracks and play counts; catalog mode only, otherwise `null` | `null` |
| `unique_tracks_in_catalog`, `catalog_total_plays`, `releases_last_12_months` | Catalog mode only: recordings counted once, their total plays, and releases from the last 12 months among the loaded ones | `87`, `450000000`, `3` |
| `scraped_at` | UTC time the artist was collected | `2026-11-07T09:00:00Z` |

The extra tables hold one row per item and repeat `artist_id`, `artist_name` and `url`:

- **top_cities:** `rank`, `city`, `country`, `region`, `listeners`, `share_of_monthly_listeners_pct`.
- **top_tracks:** `rank`, `track_id`, `track_name`, `play_count`, `duration_ms`, `explicit`, `track_artists`, `track_url`.
- **tour_dates:** `title`, `date`, `venue`, `city`, `festival`, `concert_url`.
- **related_artists:** `related_artist_id`, `related_artist_name`, `related_artist_url`, `related_monthly_listeners`.
- **playlists:** `list_type`, `playlist_name`, `playlist_owner`, `playlist_url`.
- **appears_on:** `release_id`, `release_name`, `release_artist`, `release_type`, `release_url`.
- **releases:** `release_id`, `release_name`, `release_type`, `release_date`, `total_tracks`, `total_plays`, `cover_image`, `release_url`.
- **release_tracks:** `release_id`, `release_name`, `track_number`, `track_id`, `track_name`, `play_count`, `duration_ms`, `explicit`, `track_artists`, `track_url`.
- **failed_inputs:** `input` and `error` for every input that could not be collected.

### 💡 Use cases for Spotify artist data

- **Rank artists by audience size:** read `monthly_listeners` and `world_rank` for every artist on your list to build a Spotify artist rankings sheet. Sorting your own list by `monthly_listeners` gives you a Spotify monthly listeners ranking that you control.
- **Follow growth week by week:** run the Actor on a schedule and keep every export, because `scraped_at` stamps each row. Together the files form a Spotify monthly listeners history for the artists you care about.
- **Plan tours and campaigns by city:** `top_cities` shows the listeners of each city and its share of all monthly listeners. Read it as Spotify top cities by monthly listeners before you pick tour stops. The `tour_dates` table lists Spotify tour dates, one row per concert. The same concerts sit inside the artist row as `upcoming_concerts`, which gives you Spotify artist tour dates next to the audience numbers.
- **Compare engagement:** `followers_per_monthly_listener` puts followers next to monthly listeners in a single number. It is a quick way to study Spotify followers vs monthly listeners across a roster.
- **Discover similar artists:** similar mode follows the Spotify fans also like section of each artist, and `crawl_depth` and `found_via` show how each one was reached. Open the Spotify related artists table to build a shortlist for playlists or support acts.
- **Research and scout artists:** `biography`, `verified`, `latest_release` and `days_since_latest_release` give a fast first look for music artist research. Add `social_links` to find where the artist is active.
- **Check song plays:** catalog mode makes the Actor a Spotify play count checker for one artist's tracks, because every track of the newest releases comes with its `play_count`. Run it weekly and you have a Spotify play count tracker for the artists you list.

### 🛠️ How to scrape Spotify monthly listeners

1. Create an Apify account and open **Spotify Monthly Listener Scraper** in the Apify Store.
2. Paste one artist per line into **Artists to scrape**: a link, a 22-character ID, a `spotify:artist:` URI or a name.
3. Pick **What to collect**: `profile`, `catalog` or `similar`.
4. Set **Max similar artists** and **Newest releases per artist**. Type `0` in both to keep a plain profile run.
5. Click **Start** and watch the log, where each artist shows up as soon as it is saved.
6. Open the **Output** tab and download the rows as JSON, CSV, Excel, XML or HTML.

The same form takes a long list, so it doubles as a Spotify artist scraper for bulk lookups.

#### How to see Spotify monthly listeners for a single artist

Paste one artist link, set **What to collect** to `profile` and type `0` in both number fields. The run saves one row for that Spotify artist profile, and the `monthly_listeners` field holds the number. Paste several artists to get a Spotify monthly listeners list in one run.

#### How to get a Spotify artist ranking by monthly listeners

Add all artists you want to compare, keep the `profile` mode with both numbers at `0`, then sort the exported table by `monthly_listeners` or read `world_rank`. Every artist costs one result, so the cost grows with the length of your list.

#### How to get Spotify top cities for an artist

Run any mode and open the top cities table in the Output tab, or read the `top_cities` field of the artist row. The table lists Spotify top listening cities, one row per city ordered by `rank`. The `share_of_monthly_listeners_pct` column shows how much of the artist's audience each city holds.

### 💰 How much does it cost to scrape Spotify?

Pricing is pay per event. Every artist row written to the default dataset is one `main_result` event, and that includes each similar artist the Actor adds. The eight extra tables and the `failed_inputs` table are not charged.

- **Result** (`main_result`): one event per artist row in the default dataset.
- **Actor start** (`apify-actor-start`): $0.00005 per run. The Actor is set to 1024 MB of memory, which is one start event.

Apify platform usage (compute) is billed on top of the events above.

| Plan tier | Price per 1,000 results (`main_result`) |
|---|---|
| Free | $4.00 (1,000 x $0.004) |
| Bronze | $3.50 (1,000 x $0.0035) |
| Silver | $3.20 (1,000 x $0.0032) |
| Gold and above | $2.80 (1,000 x $0.0028) |

> ⚠️ The input form defaults switch on both extras: mode `similar`, 10 similar artists and 10 newest releases. A run on the defaults can charge up to 11 results for every artist you list, the artist itself plus up to 10 similar artists. Type `0` in both number fields and choose `profile` to pay for one result per artist.

Examples (arithmetic only, start fee and platform usage not included):

- 5 artists in `profile` mode with both numbers at `0` return 5 results. That is 5 x $0.004 = $0.02 on the Free tier and 5 x $0.0028 = $0.014 on Gold.
- 5 artists on the form defaults return up to 55 results. That is 55 x $0.004 = $0.22 on the Free tier and 55 x $0.0028 = $0.154 on Gold.

Set a maximum cost per run in the run options. When the run reaches it, collection stops and every artist saved so far stays in the dataset. Current rates are on the Pricing tab.

### ⬇️ Input

The only required field is **Artists to scrape** (`urls`). Open the Input tab for every option.

> 💡 For a first test run, use one artist, `profile` mode and `0` in both number fields.

This example collects one artist profile and nothing else (the artist ID is made up):

```json
{
  "urls": ["https://open.spotify.com/artist/ExampleArtistId0000001"],
  "mode": "profile",
  "maxSimilarArtists": 0,
  "maxReleasesPerArtist": 0,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

- `urls`: required list, one entry per line. Each entry is a Spotify artist link, a 22-character artist ID, a `spotify:artist:` URI or an artist name. Duplicates are removed.
- `mode`: `profile`, `catalog` or `similar`. The form default is `similar`.
- `maxSimilarArtists`: from 0 to 5,000, form default 10. A number above 0 adds that many similar artists for each artist you listed, whatever the mode. `0` turns it off, except in `similar` mode, where `0` means the full related list of each listed artist.
- `maxReleasesPerArtist`: from 0 to 5,000, form default 10. A number above 0 loads that many of the newest releases per artist with a play count for every track, whatever the mode. `0` turns it off, except in `catalog` mode, where `0` means the whole catalog.
- `proxyConfiguration`: off by default. If Spotify refuses requests, the Actor retries and switches to a proxy by itself. You can also bring your own proxy.

### ⬆️ Output

The scraped results are shown as a dataset in the **Storage** tab, and the Output tab groups them into views: Overview, Audience, Music, Catalog, Profile, Tour and playlists, and Similar artists. The table view doesn't show **all the fields**. Open the Export menu to export Spotify artist data as JSON, CSV, Excel, XML or HTML, or read the rows through the API.

For the input above you get one row (made-up values, shortened lists):

```json
{
  "artist_id": "ExampleArtistId0000001",
  "artist_name": "Example Artist",
  "url": "https://open.spotify.com/artist/ExampleArtistId0000001",
  "verified": true,
  "monthly_listeners": 1250000,
  "followers": 480000,
  "world_rank": 2150,
  "followers_per_monthly_listener": 0.384,
  "top_cities": [
    { "city": "London", "country": "GB", "region": "ENG", "listeners": 62500, "share_of_monthly_listeners_pct": 5.0 }
  ],
  "top_city": "London",
  "top_tracks": [
    { "track_id": "ExampleTrackId00000001", "name": "Example Song One", "play_count": 9100000, "duration_ms": 201000, "explicit": false, "track_number": 1, "artists": ["Example Artist"], "url": "https://open.spotify.com/track/ExampleTrackId00000001" },
    { "track_id": "ExampleTrackId00000002", "name": "Example Song Two", "play_count": 4000000, "duration_ms": 187000, "explicit": false, "track_number": 2, "artists": ["Example Artist"], "url": "https://open.spotify.com/track/ExampleTrackId00000002" }
  ],
  "top_tracks_total_plays": 13100000,
  "album_count": 4,
  "single_count": 12,
  "compilation_count": 1,
  "latest_release": { "name": "Example Single", "type": "SINGLE", "release_date": "2026-09-12", "url": "https://open.spotify.com/album/ExampleAlbumId0000001" },
  "days_since_latest_release": 56,
  "social_links": { "instagram": "https://instagram.com/example_artist" },
  "biography": "Example Artist is a made-up artist used for this sample.",
  "avatar_image": "https://example.com/avatar.jpg",
  "header_image": "https://example.com/header.jpg",
  "gallery": [],
  "upcoming_concerts": [
    { "title": "Example Artist live", "date": "2026-12-05T20:00:00", "venue": "Example Hall", "city": "London", "festival": false, "url": "https://open.spotify.com/concert/ExampleConcert00001" }
  ],
  "upcoming_concerts_total": 1,
  "playlists_by_artist": [],
  "featured_in_playlists": [],
  "discovered_on": [],
  "discovered_on_total": 0,
  "appears_on": [],
  "appears_on_total": 0,
  "related_artists": [
    { "artist_id": "ExampleRelated00000001", "name": "Example Neighbor", "url": "https://open.spotify.com/artist/ExampleRelated00000001", "monthly_listeners": null }
  ],
  "crawl_depth": 0,
  "found_via": null,
  "releases": null,
  "scraped_at": "2026-11-07T09:00:00Z"
}
```

In `catalog` mode the row also carries `releases`, `unique_tracks_in_catalog`, `catalog_total_plays` and `releases_last_12_months`, and the `releases` and `release_tracks` tables are filled. Similar artists are saved as their own rows with `crawl_depth` 1 or more.

At the end of each run a JSON summary is saved under the key `RUN_SUMMARY` in the key-value store. It holds the number of inputs requested, artists saved and charged, inputs with problems, artists skipped, the duration in seconds and whether the spend limit was reached.

### ⚠️ Limitations and error handling

- Only public artist data is returned. Fields Spotify does not show for an artist stay `null`, for example `world_rank` for an unranked artist.
- A name is matched to the best search result, so use a link or an ID when you need one exact artist. Names with non-Latin letters take the top result without a similarity check.
- Spotify lists about 40 related artists per artist. The Actor keeps following those lists for a limited number of rounds, so a very large `maxSimilarArtists` can return fewer artists than requested.
- `appears_on` holds up to 100 releases per artist, and `releases_last_12_months` counts only the releases that were loaded.
- `monthly_listeners` of a related artist is filled only when that artist was also collected earlier in the same run.
- The numbers are the values Spotify shows when the run reads them. Run again to refresh them.
- If Spotify keeps refusing requests, the run can end with few or no rows. A short message in the log says what happened, and the rows already saved are kept.

| Situation | What you see | What to do |
|---|---|---|
| Normal finish | Status "Done: N artists saved, M inputs with problems." | Open the Output tab |
| Spend limit reached | Status "Spend limit reached after N artists." and the log line "Spend limit reached - stopping cleanly" | Raise the maximum cost per run and run again |
| Nothing collected | Status "No artists collected - see the failed inputs table or the log." | Check the links or names and read the `failed_inputs` table |
| Artist not found | A `failed_inputs` row with `error` "artist not found" | Use a link or ID instead of a name |
| Empty or invalid input | The run fails at the start with "urls is empty - give at least one Spotify artist link, ID or name" or a message about `mode` | Fill in `urls` and pick one of the three modes |

### 🔌 Integrating Spotify Monthly Listener Scraper with other apps

Besides the Console, you can start this Spotify scraper over HTTP: send your input JSON to `https://api.apify.com/v2/actors/data_wiki~spotify-monthly-listener/runs`, then read the rows from the run's dataset. The API tab of the Actor shows ready-made snippets for JavaScript, Python and the command line.

- **Recurring runs:** an [Apify schedule](https://docs.apify.com/actors/running/schedules) can run the same artist list every week. Kept together, the dated rows of every run work as a Spotify monthly listeners over time tracker.
- **Charts over time:** keep each exported file or append the rows to one sheet, then plot a Spotify monthly listeners graph from the `scraped_at` and `monthly_listeners` columns.
- **Spreadsheets and automation tools:** the [Apify integrations](https://docs.apify.com/integrations) send the dataset on to Google Sheets, [Make](https://docs.apify.com/integrations/make), [Zapier](https://docs.apify.com/integrations/zapier) and other apps, which suits Spotify artist analytics in your own reports.
- **Webhooks:** call a web address of your own when a run ends, as described in [Apify webhooks](https://docs.apify.com/integrations/webhooks).
- **Code:** the [Apify API reference](https://docs.apify.com/api/v2) lists the calls for runs and datasets.
- **AI agents:** an agent connected to the [Apify MCP server](https://docs.apify.com/mcp) can look up this Actor and run it.

### 🔗 Other scrapers by data_wiki

No Actor from this account covers Spotify or other music sites, so the links below are by use case only: researching music, trends, creators and fans on other platforms. Each one is a separate tool with its own input.

| Actor | What it extracts | When to use it |
|---|---|---|
| [TikTok Data Extractor](https://apify.com/data_wiki/tiktok-data-extractor) | TikTok videos from links, profiles, hashtags or keywords, with views, likes, shares, music and comments | You spot a song or artist in TikTok videos and want their Spotify numbers next to the trend |
| [Instagram Hashtag Scraper](https://apify.com/data_wiki/instagram-hashtag-scraper) | Public Instagram reels found by hashtag or keyword, with plays, likes, creator and music | You research which artists and sounds appear in reels, then look the artists up here |
| [Instagram Comment Scraper](https://apify.com/data_wiki/instagram-comment-scraper) | Public comments of Instagram posts and reels | An artist lists an Instagram profile in `social_links` and you want to read fan comments |
| [Threads Scraper](https://apify.com/data_wiki/threads-scraper) | Public Threads posts, profiles and replies | You follow an artist's public conversation on Threads after checking their audience here |

For trend work, [TikTok sound and video data](https://apify.com/data_wiki/tiktok-data-extractor) and [Instagram reels by hashtag](https://apify.com/data_wiki/instagram-hashtag-scraper) pair well with the audience numbers from this Actor. Source site: [Spotify](https://open.spotify.com).

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

Spotify Monthly Listener Scraper reads the same public artist pages any visitor can open. It does not log in and does not collect private data. Artist rows, bios and the `playlist_owner` field can still contain personal data, which falls under rules such as GDPR and CCPA. Decide on a lawful reason before you store or share it, follow Spotify's terms, and ask a lawyer when in doubt. Further reading: [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and [ethical web scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/).

### ❓ FAQ

#### Do I need a Spotify account or API key for the Spotify monthly listeners scraper?

No. The Actor reads public artist data and needs no Spotify login, API key or cookies. You only need an Apify account.

#### How much does a run cost?

A run costs the $0.00005 start event plus one result per artist row, from $4.00 per 1,000 results on the Free tier to $2.80 on Gold and above. Apify adds compute usage on top.

#### Why does my first run return more rows than artists?

The form defaults use `similar` mode with 10 similar artists, so each listed artist can bring up to 10 more rows, and each of them is a charged result. Choose `profile` and type `0` in both number fields for exactly one row per artist.

#### Is there an API for Spotify Monthly Listener Scraper?

Yes, the Apify API. It starts runs and returns the dataset as JSON, so you can call it from your own code. It is not an official Spotify API. If you searched for a Spotify API alternative for artist figures, this Actor needs no Spotify API key.

#### Can I look up an artist by name?

Yes. Type the name and the best search match is used, which is why a link or ID is safer when several artists share a name. The saved row shows `artist_name` and `url` so you can check which artist was picked.

#### Can I track monthly listeners over time?

Yes, with a schedule. Each run returns the current numbers with a `scraped_at` stamp, and the Actor does not keep past values for you. Keep the exports from every run to build a Spotify artist stats history. A weekly schedule is all a Spotify monthly listeners tracker needs. Plotting the saved numbers then shows Spotify artist stats over time.

#### Why do the top city numbers not add up to the monthly listeners?

The `top_cities` list covers the cities Spotify returns for the artist, not all listeners. Their total is therefore lower than `monthly_listeners`, and `share_of_monthly_listeners_pct` shows each city's part of the total.

#### Can I use it as a Spotify artist stats checker?

Yes for a quick check. Add the links, press **Start** and read `monthly_listeners`, `followers` and `world_rank` of each artist. For tracks, the `top_tracks` field holds the plays Spotify shows, a view of Spotify artist streaming data without opening each page. It also works as a Spotify play count scraper for the artists you list. Catalog mode adds Spotify song play counts for every track of the newest releases.

#### How do I check whether a Spotify artist is verified?

Read the `verified` field of the artist row. It is `true` when the artist page shows the verified badge, which makes it a fast Spotify verified artist check across a long list.

#### Can I use Spotify Monthly Listener Scraper through MCP?

Yes. An agent connected to `https://mcp.apify.com` can search for this Actor, read its input form and run it with your artist list.

### 💬 Your feedback

Found a bug or need another field? Open an issue on the Actor's Issues tab. Need a custom solution? Contact hello.datawiki@gmail.com.

# Actor input Schema

## `urls` (type: `array`):

One per line: a Spotify artist link (open.spotify.com/artist/...), a 22-character artist ID, a spotify:artist: URI or just the artist name (the best match is used). Duplicates are removed. Add as many as you like.

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

Profile: listeners, rank, top cities, top tracks and plays, tour dates, bio, socials (fastest). Catalog / Similar add releases or fans-also-like artists. You can also leave this on Profile and just type a number in 'Max similar artists' or 'Newest releases per artist' - those switch the extras on by themselves.

## `maxSimilarArtists` (type: `integer`):

Add the artists Spotify says fans also like. Type a number above 0 to switch this on (no need to change the mode): that many extra artists are added for EACH artist you listed (the limit is per input, not shared). Spotify lists about 40 related artists per artist, so the Actor keeps following those lists until your number is reached. 0 = off (if you picked the similar-artists mode, 0 means each listed artist's full related list).

## `maxReleasesPerArtist` (type: `integer`):

Add each artist's newest releases with a play count for every track. Type a number above 0 to switch this on (no need to change the mode): that many of the newest releases are loaded per artist. 0 = off (if you picked the catalog mode, 0 means the whole catalog).

## `proxyConfiguration` (type: `object`):

Optional. By default requests go out without a proxy. If Spotify refuses them, the Actor switches to a datacenter proxy and then a residential proxy on its own and stays on it.

## Actor input object example

```json
{
  "urls": [
    "https://open.spotify.com/artist/4Z8W4fKeB5YxbusRsdQVPb",
    "Taylor Swift"
  ],
  "mode": "similar",
  "maxSimilarArtists": 10,
  "maxReleasesPerArtist": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per artist.

## `audience` (type: `string`):

Listeners, followers, world rank and top cities.

## `music` (type: `string`):

Top tracks, plays and release counts.

## `profile` (type: `string`):

Bio, verified badge, social links and images.

## `topCities` (type: `string`):

One row per top city of each artist.

## `topTracks` (type: `string`):

One row per top track with play counts.

## `tourDates` (type: `string`):

One row per upcoming concert.

## `relatedArtists` (type: `string`):

One row per artist fans also like.

## `playlists` (type: `string`):

Playlists by, featuring and discovering the artist.

## `appearsOn` (type: `string`):

Releases of other artists featuring the artist.

## `releases` (type: `string`):

One row per release (catalog mode).

## `releaseTracks` (type: `string`):

One row per track with play count (catalog mode).

## `failedInputs` (type: `string`):

Inputs that could not be scraped.

## `summary` (type: `string`):

Counts and timing of the run.

# 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 = {
    "urls": [
        "https://open.spotify.com/artist/4Z8W4fKeB5YxbusRsdQVPb",
        "Taylor Swift"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_wiki/spotify-monthly-listener").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 = {
    "urls": [
        "https://open.spotify.com/artist/4Z8W4fKeB5YxbusRsdQVPb",
        "Taylor Swift",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_wiki/spotify-monthly-listener").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "urls": [
    "https://open.spotify.com/artist/4Z8W4fKeB5YxbusRsdQVPb",
    "Taylor Swift"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_wiki/spotify-monthly-listener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_wiki/spotify-monthly-listener"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OYIb933ji24gUVpt4/builds/hGtLrO81FjLaPiWua/openapi.json