# Spotify Scraper (`scrapesmith/spotify-scraper`) Actor

🔥0.40/1000 results🔥Spotify scraper. 9 modes: albums, artists, tracks, playlists, podcasts, episodes, search, play counts & full discography cascade. 27+ fields per record — No login, no proxy, no setup. JSON/CSV/Excel. API, MCP server, webhook, Claude, ChatGPT, LangChain, Make, Zapier, n8n ready.

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

## Pricing

from $0.40 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper — Play Counts, ISRC, Albums, Artists, Playlists, Podcasts & Search | All-In-One

The most complete and affordable Spotify data extraction tool on the Apify Store. **9 modes in one actor** — get everything you need from Spotify without juggling multiple scrapers or paying per data type.

### 🏆 Why this scraper

- 💰 **Cheapest all-in-one on the store** — albums, artists, tracks, playlists, podcasts, and search all included. No separate charges per mode.
- 🔢 **Real play counts** — exact stream numbers, not estimates. The same data the industry uses for charting and analytics.
- 🎯 **27+ fields per record** — more data points than any competitor. ISRC codes, popularity scores, audio previews, verified badges, monthly listeners, world rankings, top cities, and much more.
- 🚀 **Zero setup** — no Spotify account, no API keys, no cookies, no configuration. Paste a link and get structured data back instantly.
- 📀 **Full discography cascade** — toggle one setting and get every track from every album and single an artist has ever released, each with its own play count.
- 🎙️ **Podcasts & episodes** — search and extract show metadata, episode details, and audio previews. A feature no other Spotify actor offers.
- 📊 **Built for any scale** — works the same whether you're looking up a single track or extracting tens of thousands of playlist tracks.
- 🔍 **Powerful search** — find tracks, artists, albums, playlists, podcasts, and episodes with free-text queries. Up to 1,000 results per search with full pagination.

### 🎧 What you can extract

| Mode | What you get |
|---|---|
| 🎵 **Album** | Every track with play count, duration, ISRC, popularity, cover art, label, copyright |
| 🎤 **Artist** | Followers, monthly listeners, world rank, verified badge, top cities, top tracks, related artists, biography, social links, discography overview |
| 🎶 **Track** | Full metadata with exact play count, ISRC, popularity, audio preview URL, content rating |
| 📋 **Playlist** | Every track with play count, position, who added it and when, playlist follower count |
| 🔎 **Search** | Tracks, artists, albums, playlists, podcasts, and episodes matching any query |
| 🎙️ **Podcast/Show** | Publisher, description, episode count, languages, cover art |
| 📻 **Episode** | Duration, release date, language, audio preview, parent show info |
| ⚡ **Play counts** | Lightweight mode — just ID, name, artist, and exact stream count |
| 📀 **Artist cascade** | Artist profile + every track from their full discography with per-track play counts |

**Mixed input supported** — drop album URLs, artist links, track IDs, and playlist URIs into the same list. The actor auto-detects each one.

### 📥 Input

| Field | Description |
|---|---|
| `mode` | Choose a specific mode or leave on **Auto-detect** to let the actor figure it out from your links |
| `ids` | Spotify URLs, URIs (`spotify:track:...`), or bare IDs — one or many |
| `searchQueries` | Free-text search terms for finding music, artists, or podcasts |
| `searchTypes` | Which types to include in search results (tracks, artists, albums, playlists, shows, episodes) |
| `followDiscography` | When scraping an artist, also extract all their albums, singles, and compilations with per-track play counts |
| `maxItemsPerInput` | Limit results from a single playlist, album, or search query |
| `maxItems` | Overall cap for the entire run |

### 📤 Sample output — Track

```json
{
  "mode": "track",
  "id": "0VjIjW4GlUZAMYd2vXMi3b",
  "url": "https://open.spotify.com/track/0VjIjW4GlUZAMYd2vXMi3b",
  "name": "Blinding Lights",
  "primaryArtist": "The Weeknd",
  "albumName": "After Hours",
  "playcount": 5498339860,
  "popularity": 92,
  "isrc": "USUG11904206",
  "durationFormatted": "3:20",
  "previewUrl": "https://p.scdn.co/mp3-preview/...",
  "releaseDate": "2020-03-20T00:00:00Z",
  "isExplicit": false,
  "trackNumber": 9,
  "coverUrl": "https://i.scdn.co/image/..."
}
````

### 📤 Sample output — Artist

```json
{
  "mode": "artist",
  "name": "The Weeknd",
  "verified": true,
  "popularity": 95,
  "followers": 125056182,
  "monthlyListeners": 113605709,
  "worldRank": 3,
  "topCities": [{"city": "Mexico City", "country": "MX", "listeners": 1633973}],
  "topTracks": [{"name": "Blinding Lights", "playcount": 5498339860}],
  "relatedArtists": [{"name": "Doja Cat"}, {"name": "Rihanna"}],
  "externalLinks": [{"name": "INSTAGRAM", "url": "https://instagram.com/theweeknd"}],
  "albumsTotal": 14,
  "singlesTotal": 65
}
```

### 💡 Use cases

- 🎵 **Music industry analytics & A\&R** — monitor play-count growth, spot breakout tracks, evaluate catalog performance
- 📋 **Playlist intelligence** — audit editorial playlists, track placement trends, measure playlist reach
- 🎤 **Artist monitoring** — followers, listeners, world rank, discography expansion over time
- 🏷️ **Rights management & catalog matching** — use ISRC codes to identify recordings across platforms and distributors
- 🎙️ **Podcast research** — discover shows, track episode output, monitor publisher activity
- 📊 **Dashboards & data feeds** — clean structured data ready for BI tools, data warehouses, or AI workflows
- 🔍 **Market research** — search the entire Spotify catalog with full metadata for competitive analysis

### 🔗 API, MCP server & integrations

This actor plugs into any workflow with zero custom code:

- 🌐 **REST API & webhooks** — trigger runs, poll results, or get notified on completion
- 🤖 **MCP server** — use as a tool from **Claude**, **ChatGPT**, **LangChain**, or any MCP-compatible AI agent
- ⚙️ **No-code platforms** — works with **Make** (Integromat), **Zapier**, **n8n**, and other automation tools
- 📁 **Export formats** — JSON, CSV, Excel — download or stream via API
- 🔄 **Scheduling** — set up recurring runs to track trends over time

### ❓ FAQ

**Do I need a Spotify account or API key?**
No — everything uses public data. No login, no setup, no credentials.

**Does it work for any track, album, or artist?**
Yes — from global #1 hits to niche independent releases, user-created playlists, and small podcasts.

**How current are the play counts?**
Pulled fresh on every run — the same numbers Spotify displays at that moment.

**Can I get play counts for an entire album or playlist?**
Yes — album mode and playlist mode both return per-track play counts automatically.

**Can I get an artist's full catalog with play counts?**
Yes — enable `followDiscography` and the actor fetches every album, single, and compilation with per-track stream counts.

**What about podcasts?**
Search mode finds shows and episodes. You can also scrape show and episode details directly by URL.

**Can I search instead of pasting links?**
Absolutely — search mode supports free-text queries across tracks, artists, albums, playlists, podcasts, and episodes with pagination up to 1,000 results per query.

**What format is the output?**
Structured JSON with zero null values. Export as JSON, CSV, or Excel from the Apify console or API.

**Is there a free tier?**
Yes — every user gets free results to try the actor before committing to a paid plan.

# Actor input Schema

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

What to scrape. Leave on Auto-detect to infer the type from each URL/URI in Spotify links/IDs.

## `ids` (type: `array`):

One or more Spotify URLs (open.spotify.com/...), URIs (spotify:track:...), or bare IDs — albums, artists, tracks or playlists.

## `searchQueries` (type: `array`):

Free-text search terms (song, artist or playlist names). Used when you want search results instead of specific links.

## `searchTypes` (type: `array`):

Which entity types to include in search results.

## `followDiscography` (type: `boolean`):

When scraping an artist, also scrape all their albums, singles and compilations to get every track with play counts.

## `maxItemsPerInput` (type: `integer`):

Cap on tracks pulled from a single playlist, album, search query, or artist cascade.

## `maxItems` (type: `integer`):

Overall cap on results across all inputs for this run. Leave blank for no extra cap (plan limits still apply).

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

Optional proxy. Not required — the actor works without a proxy.

## Actor input object example

```json
{
  "mode": "auto",
  "ids": [
    "https://open.spotify.com/track/0VjIjW4GlUZAMYd2vXMi3b"
  ],
  "searchTypes": [
    "track",
    "artist",
    "album",
    "playlist"
  ],
  "followDiscography": false,
  "maxItemsPerInput": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "ids": [
        "https://open.spotify.com/track/0VjIjW4GlUZAMYd2vXMi3b"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/spotify-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "ids": ["https://open.spotify.com/track/0VjIjW4GlUZAMYd2vXMi3b"] }

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

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

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

```

## CLI example

```bash
echo '{
  "ids": [
    "https://open.spotify.com/track/0VjIjW4GlUZAMYd2vXMi3b"
  ]
}' |
apify call scrapesmith/spotify-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Scraper",
        "description": "🔥0.40/1000 results🔥Spotify scraper. 9 modes: albums, artists, tracks, playlists, podcasts, episodes, search, play counts & full discography cascade. 27+ fields per record — No login, no proxy, no setup. JSON/CSV/Excel. API, MCP server, webhook, Claude, ChatGPT, LangChain, Make, Zapier, n8n ready.",
        "version": "0.0",
        "x-build-id": "hp7RginIBStfiRJRu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~spotify-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-spotify-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesmith~spotify-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-spotify-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesmith~spotify-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-spotify-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "auto",
                            "album",
                            "artist",
                            "track",
                            "playlist",
                            "show",
                            "episode",
                            "search",
                            "playcount"
                        ],
                        "type": "string",
                        "description": "What to scrape. Leave on Auto-detect to infer the type from each URL/URI in Spotify links/IDs.",
                        "default": "auto"
                    },
                    "ids": {
                        "title": "Spotify links, URIs or IDs",
                        "type": "array",
                        "description": "One or more Spotify URLs (open.spotify.com/...), URIs (spotify:track:...), or bare IDs — albums, artists, tracks or playlists.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Free-text search terms (song, artist or playlist names). Used when you want search results instead of specific links.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTypes": {
                        "title": "Search result types",
                        "type": "array",
                        "description": "Which entity types to include in search results.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "track",
                                "artist",
                                "album",
                                "playlist",
                                "show",
                                "episode"
                            ]
                        },
                        "default": [
                            "track",
                            "artist",
                            "album",
                            "playlist"
                        ]
                    },
                    "followDiscography": {
                        "title": "Follow artist discography",
                        "type": "boolean",
                        "description": "When scraping an artist, also scrape all their albums, singles and compilations to get every track with play counts.",
                        "default": false
                    },
                    "maxItemsPerInput": {
                        "title": "Max items per input",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on tracks pulled from a single playlist, album, search query, or artist cascade.",
                        "default": 1000
                    },
                    "maxItems": {
                        "title": "Max total results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Overall cap on results across all inputs for this run. Leave blank for no extra cap (plan limits still apply)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. Not required — the actor works without a proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
