Spotify Artist Scraper - Listeners & Followers

What does the Spotify Artist Scraper do?

Give it a list of Spotify artists and it returns one row each, with the audience figures as exact integers. monthlyListeners comes back as 100593317, not as the "100.6M" the artist page renders. followerCount is the same: a whole number, straight out of Spotify's own response. Every top track carries its play count as an integer too.

That distinction matters the moment you start tracking a number over time. A rounded display figure moves in steps of a hundred thousand, which means a week of real growth can look like no change at all and then jump. Exact integers give you a real series to difference.

You supply the artists; the Actor does not do discovery. IDs, spotify:artist: URIs and open.spotify.com artist URLs all work and all collapse to the same fetch, so a mixed list is never billed twice for one artist.

• No Spotify account, developer app, client secret or Web API quota is involved
• Up to 200 artists per run, fetched in parallel
• topTracks gives you the artist page's track list with an ID, a name and an exact play count each
• An ID Spotify does not recognise is reported as a failure rather than written out as an all-null row that counts as a success
• The token and query the run needs are fetched once, not once per artist, so the overhead amortises across a large roster

What data does it extract?

Field	Type	Description
artistId	string	Spotify's 22-character artist ID
name	string	Artist name as Spotify publishes it
monthlyListeners	number	Exact integer, e.g. 100593317
followerCount	number	Exact integer, e.g. 54812903
isVerified	boolean	Whether Spotify shows the artist as verified
topTracks	object[]	{ trackId, name, playCount } per track, playCount an exact integer
imageUrl	string	Artist avatar, the widest of the sizes Spotify ships
artistUrl	string	https://open.spotify.com/artist/<artistId>
sourceUrl	string	The query URL this row was read from
collectedAt	string	ISO timestamp, set once per run
popularity	null	Always empty. See below
genres	string[]	Always empty. See below

On exactness, since it is the point of this Actor. followerCount and monthlyListeners are integers read directly out of Spotify's own JSON response. They are not parsed back from display text, and no compact-number expansion happens anywhere: nothing here turns "100.6M" into 100600000. Play counts arrive from Spotify as decimal strings and are converted to numbers as they stand, with no rounding. So if you diff two runs a week apart, the difference is real movement rather than a rendering artefact.

On the two empty columns. popularity and genres are Spotify Web API fields with no counterpart anywhere in the public web player's data, and the Web API needs a client credential this Actor deliberately does not use. They are carried as null and [] so that every row in the dataset has the same column set, which keeps CSV exports and warehouse loads stable. They are not part of the default table view. If you need genres or the popularity score, you need a Spotify developer app and the Web API, not a scraper.

Why scrape Spotify artist data?

The buyers for this are labels, distributors, A&R teams and music analytics shops, and the use cases mostly come down to watching a number that Spotify does not let you export.

• A&R scouting on a real number. Rank a watchlist by exact monthly listeners rather than by a rounded figure that buckets a hundred artists into the same "1.2M". Week-over-week deltas on a few hundred unsigned artists are where the signal is.
• Roster reporting. Run your whole roster on a schedule and you have a dated table of listeners, followers and per-track play counts to put in front of a label services team or an investor.
• Audience conversion. followerCount against monthlyListeners is a rough measure of how much of an artist's passive listening has turned into intent. A high listener count on a thin follower base reads very differently from the reverse, especially for playlist-driven artists.
• Catalogue and release tracking. topTracks play counts show which songs are actually carrying an artist, and whether a new release has displaced the back catalogue or just landed beside it.
• Deal diligence and valuation. For catalogue acquisition or an advance, a series of dated exact play counts per track is far more useful than a screenshot of a rounded figure.
• Enriching a rights or metadata database. artistId is Spotify's own key, so rows join cleanly to anything else you hold keyed on Spotify URIs.

How to use it

1. Open the Actor and click Try for free.
2. Put your artists into Artists, one per line. The easiest source is the Spotify app: right-click an artist, Share, Copy link to artist, and paste. Plain 22-character IDs and spotify:artist: URIs work equally well.
3. Leave Maximum results alone for most runs. The artists input already caps at 200, so it only matters if you want fewer rows than artists.
4. Click Start. The run fetches its session once, then one request per artist at the concurrency you set.
5. Export the dataset from the Storage tab as CSV, JSON or Excel, or read it over the API.
6. For a growth series, put the run on a Schedule and append each run's rows to a table keyed on artistId and collectedAt.

Input

Field	Type	Default	Description
artists	string[]	required	Spotify artist IDs, spotify:artist: URIs or open.spotify.com artist URLs. 1 to 200 per run
maxItems	integer	1000	Cap on dataset rows, 1 to 50000
concurrency	integer	5	Artists fetched in parallel, 1 to 10

{
  "artists": [
    "4gzpq5DPGxSnKTe4SA8HAU",
    "spotify:artist:06HL4z0CvFAxyc27GXpf02",
    "https://open.spotify.com/artist/3TVXtAsR1Inumwj472S9r4"
  ],
  "concurrency": 5
}

An ID, a URI and a full URL for the same artist resolve to one target, so duplicates in your list do not cost extra fetches or produce extra rows. Anything that is not a 22-character Spotify ID is rejected before it costs a fetch and appears in the run's failure list. That includes artist names: this Actor takes artists you already know, and there is no search by name.

Output

One row per artist. This is the shape, with plausible values rather than a captured run:

{
  "artistId": "4gzpq5DPGxSnKTe4SA8HAU",
  "name": "The Weeknd",
  "followerCount": 96437215,
  "monthlyListeners": 100593317,
  "popularity": null,
  "genres": [],
  "isVerified": true,
  "topTracks": [
    { "trackId": "0VjIjW4GlUZAMYd2vXMi3b", "name": "Blinding Lights", "playCount": 4917364118 },
    { "trackId": "2LBqCSwhJGcFQeTHMVGwy3", "name": "Die For You", "playCount": 2801945011 },
    { "trackId": "7CyPwkp0oE8Ro9Dd5CUDjW", "name": "One Of The Girls", "playCount": 1642087339 }
  ],
  "imageUrl": "https://i.scdn.co/image/ab6761610000e5eb214f3cf1cbe7139c1e26ffbb",
  "artistUrl": "https://open.spotify.com/artist/4gzpq5DPGxSnKTe4SA8HAU",
  "sourceUrl": "https://api-partner.spotify.com/pathfinder/v1/query?operationName=queryArtistOverview",
  "collectedAt": "2026-08-19T09:14:02.771Z"
}

sourceUrl is the artist-overview query the row was read from; the sample above trims its query string, which in a real run also carries the artist URI and the persisted-query hash.

The run also writes a SUMMARY record to the key-value store with the item count, the failure count and every artist that failed, each with its error.

How it reads exact figures

Worth understanding, because it explains both the accuracy and the shape of the run.

The Spotify artist page renders nothing server-side. An ordinary fetch returns the web-player shell, and pointing a crawler user-agent at it only upgrades that to Open Graph tags whose listener count is already rounded for display. Reading the page, in other words, gets you "100.6M" at best.

The exact figures come from queryArtistOverview, the same call the web player makes for its own artist page. That call needs two things, and Spotify's public pages hand out both: an anonymous bearer token, which any /embed/ page mints server-side, and the persisted-query hash for the operation, which is safelisted and therefore has to be read out of the web-player bundle rather than invented. An unregistered query is refused outright.

The Actor collects both once per run, in three fetches: the open.spotify.com shell, the bundle it links, and one /embed/artist/ page. Then it issues one request per artist. Because the bootstrap is per run rather than per artist, its cost disappears into a long list. If the bootstrap fails, the run fails once with that error rather than reporting every artist on your list as separately broken.

Reliability and limitations

Every field comes out of Spotify's GraphQL response rather than from rendered markup, so a value is either present and exact or absent. Nothing is inferred from a display string.

An artist ID Spotify does not know answers with HTTP 200 and an empty record, which would otherwise reach the dataset as an all-null row counted as a success. That case is caught and recorded under failures in the run's SUMMARY instead. A run in which every artist failed exits with an error.

Artist-level data only. No full discography, no album or playlist listings, no track audio features, no related artists and no search. The topTracks list is the one the artist page shows, not the complete catalogue. Only spotify.com URLs are accepted; a link on any other host is rejected before it costs a fetch.

There are no retries, deliberately. The String Unblocker owns proxy rotation and anti-bot solver selection, so a retry loop here would only re-roll the same block.

How much does it cost?

The Actor uses Apify's pay-per-event pricing and charges once per result row written to the dataset, which here means once per artist successfully collected. You pay for rows, not for run time, memory or the three bootstrap fetches, and a run that returns nothing charges nothing. The current per-result price is on the pricing tab above.

Charging happens on the push, so an account spend limit trims the write rather than overrunning it. A row that could not be charged for is never written.

Runs started from an Apify free plan stop at 250 requests and 250 results and report that they reached the limit. Since the artists input already caps at 200, a free-plan run is bound by that ceiling in practice rather than by the limit. Any paid plan runs the full input and whatever maxItems you set. The limit exists because this Actor fetches through our own infrastructure, which Apify does not cover for free-plan runs.

Using it with the Apify API

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });

const run = await client.actor("usestring/spotify-artists").call({
  artists: [
    "4gzpq5DPGxSnKTe4SA8HAU",
    "https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02"
  ]
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const artist of items) {
  console.log(artist.name, artist.monthlyListeners, artist.followerCount);
}

The same call works from the Python client, or against the Apify REST API in any language. To see which artists failed and why, read the SUMMARY record from the run's key-value store.

Is it legal to scrape Spotify?

The Actor reads figures Spotify publishes on public artist pages, with no login and no paywall in between. It does not sign in, does not touch listening history, playlists or any user account, and collects no personal data. An artist page is a promotional surface, and the follower and listener counts on it are published deliberately.

Scraping public data is broadly lawful in the US and the EU. What you do with it afterwards is a different question, governed by copyright, database rights and Spotify's own terms, and reselling a derived dataset is a materially different act from using it internally for scouting or reporting. Artist images belong to their rights holders. Take legal advice before you republish or resell. Nothing here is legal advice.

Related actors

• TikTok Profile Scraper for the other surface an artist's audience shows up on, with exact follower and like counts
• LinkedIn Profile Scraper for the people side of a label, management company or distributor
• Yahoo Finance Quote Scraper if you are tracking the listed music groups alongside the artists

FAQ

Are the monthly listeners exact or rounded? Exact. monthlyListeners and followerCount are integers taken straight from Spotify's JSON, and every topTracks[].playCount is exact as well. Nothing in this Actor expands a display string such as "100.6M" into a number, so a difference between two runs is real movement.

Do I need a Spotify account, API key or client credentials? No. The Actor uses the anonymous access token that Spotify's own public /embed/ page mints, so there is no login, no developer app and no client secret. It is also not subject to Web API rate quotas.

Can I search Spotify by artist name? No. You supply artist IDs, URIs or artist URLs. A name is rejected as an invalid target before any fetch is spent on it, and appears in the run's failure list. Get an ID from the Spotify app with Share, Copy link to artist.

How many artists can one run collect? Up to 200, which is the ceiling on the artists input. For a larger roster, split it across several runs or several scheduled runs.

Does it return albums, full discographies or playlists? No. It returns artist-level fields plus the top-tracks list Spotify shows on the artist page. There is no album, playlist or audio-features data, and no related-artists graph.

How fresh is the data, and what happens when an artist fails? Each artist is fetched live when the run starts, and collectedAt stamps that moment. Nothing is cached between runs. An artist that fails, including an ID Spotify does not recognise, is recorded under failures in the run's SUMMARY and the rest of the list continues. If every artist failed, the run exits with an error.

Why are genres and popularity always empty? Because they exist only in Spotify's Web API, which needs a client credential this Actor does not use. They are kept as empty columns so the dataset has one stable shape per row.

Feedback

If a figure looks wrong, an artist consistently fails, or there is a field on the artist page you want returned, open an issue from this Actor's Issues tab on the Store page and include the IDs you ran.