# Spotify Scraper - Monthly Listeners, Play Counts & Podcasts (`scrapesage/spotify-scraper`) Actor
Scrape Spotify artists, tracks, albums, playlists & podcasts — including monthly listeners, world rank, top cities, exact play counts, followers & artist contact leads. Data the official API hides. No API key, no login. Search or paste URLs, monitor stats over time.
- **URL**: https://apify.com/scrapesage/spotify-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $5.00 / 1,000 artist records
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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 — Artists, Monthly Listeners, Play Counts & Podcasts
Extract **complete Spotify data** — including the numbers the official Spotify API will not give you: an artist's **monthly listeners**, **world rank**, **top cities** (with per-city listener counts), and **exact play counts** for every track. Pull artists, tracks, albums, playlists, podcasts and episodes by search or by URL, and optionally turn any artist into a **ready-to-contact lead** with emails, phones and socials.
No API key, no login, no browser — fast JSON extraction straight from Spotify's own web back end, with 99%+ reliability.
### Why this Spotify scraper?
The official Spotify Web API hides the metrics that actually matter — it returns followers and a 0–100 popularity score, but **never monthly listeners or real play counts**. This actor reads the same internal endpoints the Spotify web player uses, so it ships the **richest dataset in the category**:
| Data | Official API / typical scrapers | This actor |
|---|---|---|
| Artist **monthly listeners** | ❌ not available | ✅ exact |
| Artist **world rank** | ❌ | ✅ |
| **Top cities** + listeners per city | ❌ | ✅ |
| **Exact play count** per track | ❌ | ✅ |
| Album play counts + total streams | ❌ | ✅ |
| Followers, verified, biography, genres of images | partial | ✅ |
| Artist **website + Instagram/Twitter/Facebook** | ❌ | ✅ |
| Artist **contact emails / phones** (lead score) | ❌ | ✅ opt-in |
| Playlist followers + full tracklist | partial | ✅ |
| Podcast shows + episodes | partial | ✅ |
| Monitor stats over time (only new / changed) | ❌ | ✅ |
### Use cases
- **Artist & label analytics** — track **monthly listeners**, **play counts**, followers and world rank for any roster of artists; benchmark against competitors; watch growth over time with monitor mode.
- **Music marketing & lead generation** — artists are active buyers of distribution, promo, sync, and PR. Score them by reach (`monthlyListeners`, `followers`) and contact them directly with `leadEmails` from their own website.
- **Playlist pitching & tracking** — find playlists by keyword, see follower counts and full tracklists, and monitor editorial/curator playlists for new placements.
- **A&R and scouting** — discover rising artists by `worldRank`, top cities and related artists; spot momentum before everyone else.
- **Podcast intelligence** — pull podcast shows and episodes, publishers and release cadence for research, monitoring and discovery.
- **Catalog & metadata** — build music apps, recommendation engines and dashboards with clean, structured artist/track/album data including ISWC-grade identifiers (Spotify IDs/URIs).
### How to use
1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Spotify Scraper**, enter search keywords (and pick a result type), or paste Spotify URLs, and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).
### Input
```json
{
"searchQueries": ["Taylor Swift", "The Weeknd"],
"searchType": "artist",
"startUrls": [
"https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02",
"https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M"
],
"market": "US",
"enrichArtistContacts": true,
"includeArtistDiscography": false,
"monitorMode": false
}
````
- **searchQueries** — keywords to search (artist, song, album, playlist or podcast name). Each returns the **searchType** you choose.
- **searchType** — `artist` (monthly listeners + play counts), `track`, `album`, `playlist`, `podcast`, `episode`, or `all`.
- **startUrls** — paste any Spotify links/URIs (artist, track, album, playlist, `/show/…`, episode). `spotify:artist:…` URIs and `intl-xx` links work too.
- **market** — two-letter country code (`US`, `GB`, `DE`, `BR`…) for availability & podcast catalogs.
- **includeArtistDiscography / includeRelatedArtists** — add the artist's full release list / similar artists.
- **enrichArtistContacts** *(default false)* — visit each artist's own website (home + about/contact, max 3 pages) for booking/management **emails**, phones and extra socials, then add a 0–100 lead score. Spotify never exposes emails — this is the only way to get them.
- **includeAlbumTracks / includePlaylistTracks / includeShowEpisodes** — include full tracklists / episode lists (on by default).
- **monitorMode** *(default false)* — emit only records that are new or whose stats changed since the last run (see below).
### Output
One record per entity, with a `type` field (`artist`, `track`, `album`, `playlist`, `podcast`, `episode`):
```json
{
"type": "artist",
"id": "06HL4z0CvFAxyc27GXpf02",
"uri": "spotify:artist:06HL4z0CvFAxyc27GXpf02",
"url": "https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02",
"name": "Taylor Swift",
"verified": true,
"monthlyListeners": 101961299,
"followers": 159206573,
"worldRank": 6,
"topCities": [
{ "city": "London", "country": "GB", "listeners": 1687362 },
{ "city": "São Paulo", "country": "BR", "listeners": 1102456 }
],
"topTracks": [
{ "name": "The Fate of Ophelia", "playcount": 1454177486, "durationMs": 226073 }
],
"albumsCount": 33,
"singlesCount": 84,
"compilationsCount": 6,
"biography": "And, baby, that's show business for you…",
"avatarImage": "https://i.scdn.co/image/…",
"website": "https://www.taylorswift.com",
"instagram": "https://instagram.com/taylorswift",
"twitter": "https://twitter.com/taylorswift13",
"facebook": "https://facebook.com/TaylorSwift",
"leadEmails": ["management@example.com"],
"leadScore": 88,
"scrapedAt": "2026-06-17T12:00:00.000Z"
}
```
Tracks include exact `playcount`; albums include `label`, `copyrights` and per-track play counts; playlists include `followers` and tracklists; podcasts include `publisher` and episode lists.
### Monitor new & changed stats
Turn on **monitorMode** and the actor remembers each record's key stat in a named key-value store, emitting **only** records that are new or whose numbers changed — monthly listeners, play counts, followers, or episode counts.
- Pair it with **[Schedules](https://docs.apify.com/platform/schedules)** to chart an artist's monthly-listener growth, a playlist's follower trend, or a podcast's new episodes.
- It **complements** the Apify scheduler rather than conflicting with it: the schedule starts the run on your cadence, and monitor mode dedupes each run against all prior runs (use a distinct `monitorKey` per roster/feed to run several trackers independently).
### Automate & schedule
Run this actor on autopilot and pull results into your own stack:
- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily/weekly to track stats, new releases, or playlist placements.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, dashboard refresh) the moment a run finishes.
```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });
const run = await client.actor('scrapesage/spotify-scraper').call({
searchQueries: ['indie pop'],
searchType: 'artist',
enrichArtistContacts: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} Spotify records`);
```
### Integrate with any app
Connect the dataset to 5,000+ apps — no code required:
- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new artist leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored artist or playlist changes.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.
### Use with AI assistants (MCP)
The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the monthly listeners and top cities for these artists" and let it run this scraper for you.
### Agent-ready: autonomous payments (x402 & Skyfire)
This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:
- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.
Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.
### More scrapers from scrapesage
Build a complete **music & creator-economy data stack**:
- **[SoundCloud Scraper](https://apify.com/scrapesage/soundcloud-scraper)** — artists, tracks, plays & creator leads from SoundCloud.
- **[Apple Podcasts Scraper](https://apify.com/scrapesage/apple-podcasts-scraper)** — podcasts, episodes & owner-email leads.
- **[Discogs Scraper](https://apify.com/scrapesage/discogs-scraper)** — vinyl/CD releases, marketplace prices & seller leads.
- **[Reverb Scraper](https://apify.com/scrapesage/reverb-scraper)** — musical-instrument listings, price guide & seller leads.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** — videos, channels & creator contact leads.
- **[Substack Scraper](https://apify.com/scrapesage/substack-scraper)** — newsletters, subscriber estimates & author leads.
- **[Patreon Scraper](https://apify.com/scrapesage/patreon-scraper)** — creators, membership tiers & earnings estimates.
- **[Linktree Scraper](https://apify.com/scrapesage/linktree-scraper)** — creator bio links, emails & leads.
- **[Bluesky Scraper](https://apify.com/scrapesage/bluesky-scraper)** — social profiles, posts & creator leads.
### Tips
- **Richest records cost nothing extra to start** — artist records already include monthly listeners, play counts, top cities and socials. Add discography, related artists, or contact enrichment only when you need them.
- **Paste URLs for precision** — to track a specific roster, paste their artist URLs in `startUrls`; use `searchQueries` for discovery.
- **Recurring tracking** — combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to log how stats change over time.
- **Proxies** — keep the default datacenter proxy; a fresh session per request spreads Spotify's per-IP rate limit and keeps runs cheap.
### FAQ
**Can I get an artist's monthly listeners?** Yes — `monthlyListeners` is on every artist record, along with `worldRank` and `topCities`. These are not available through Spotify's official API; this actor reads the same endpoints Spotify's own web player uses.
**Can I get real play counts?** Yes — every track has an exact `playcount`, and album records sum them into `totalPlaycount`. Artist records include the top tracks with play counts.
**Do I need a Spotify API key or login?** No. The actor mints a short-lived anonymous token automatically and self-heals if Spotify rotates anything, so it just works with no credentials.
**Where do the artist emails come from?** Never from Spotify (they don't publish emails). With `enrichArtistContacts` on, the actor visits the artist's own public website and extracts publicly listed contact emails — the same thing a human visitor would see.
**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).
**How do I monitor stats automatically?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules); each run emits only records whose stats changed, so you build a clean time series.
**Is scraping Spotify legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and Spotify's terms.
**A field is null — why?** Some entities genuinely don't publish a website, biography, or every stat. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.
### Need help?
Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.
# Actor input Schema
## `searchQueries` (type: `array`):
Things to search Spotify for — an artist, song, album, playlist or podcast name, e.g. Taylor Swift, bohemian rhapsody, lofi beats, The Joe Rogan Experience. Each query returns the chosen Result type below. Leave empty if you only paste URLs.
## `searchType` (type: `string`):
What kind of records keyword searches return. Artist = full profile with monthly listeners & play counts (the headline). Track / Album / Playlist = music records. Podcast / Episode = podcast shows & episodes. All mixes every type.
## `startUrls` (type: `array`):
Paste any Spotify links or URIs to scrape directly — artists (open.spotify.com/artist/…), tracks, albums, playlists, podcasts (/show/…) or episodes. spotify:artist:… URIs and intl-xx links work too. Used in addition to the search.
## `market` (type: `string`):
Two-letter country code for availability, podcast catalogs and localized results, e.g. US, GB, DE, BR.
## `resultsPerSearch` (type: `integer`):
How many records to fetch for each keyword (capped by Max results overall).
## `includeArtistDiscography` (type: `boolean`):
Add the artist's album/single/compilation list (title, type, year). Adds one request per artist. Counts are always included.
## `maxDiscographyItems` (type: `integer`):
Maximum releases to include when discography is on.
## `includeRelatedArtists` (type: `boolean`):
Add up to 20 related/similar artists (name + id) for discovery and graph-building.
## `enrichArtistContacts` (type: `boolean`):
Turn each artist into a B2B lead: when they list their own website, visit it (home + about/contact, max 3 pages) for publicly listed booking/management emails, phones and extra socials, then add a 0–100 lead score. Spotify never exposes emails — this is the only way to get them.
## `includeAlbumTracks` (type: `boolean`):
Include each album's full tracklist with per-track play counts. Turn off for a lighter album record (label, copyrights, totals only).
## `maxTracksPerAlbum` (type: `integer`):
Cap the tracklist length per album.
## `includePlaylistTracks` (type: `boolean`):
Include each playlist's tracks (track, artists, album). Turn off to only get name, owner, follower count & total tracks.
## `maxTracksPerPlaylist` (type: `integer`):
Cap the number of tracks pulled per playlist.
## `includeShowEpisodes` (type: `boolean`):
Include a page of a podcast show's episodes (title, description, duration, release date). Turn off for show metadata only.
## `maxEpisodesPerShow` (type: `integer`):
Cap the number of episodes pulled per podcast show.
## `maxResults` (type: `integer`):
Maximum number of records to scrape across all searches and URLs.
## `deduplicate` (type: `boolean`):
Drop duplicate records that match more than one keyword/URL in the same run.
## `monitorMode` (type: `boolean`):
Remember each record's key stat across runs in a named key-value store and emit ONLY records that are new or whose stats CHANGED (monthly listeners, play count, followers, episode count). Pair with Apify Schedules to track an artist's growth, a playlist's followers, or a podcast's new episodes over time — it complements the scheduler (the schedule starts the run, monitor mode dedupes against prior runs).
## `monitorKey` (type: `string`):
Names the monitor's memory store so you can run several independent monitors (e.g. one per artist roster or playlist set). Reuse the same key to keep tracking the same feed.
## `maxConcurrency` (type: `integer`):
Parallel requests. Each uses a fresh proxy IP to spread Spotify's per-IP rate limit; keep this modest.
## `proxyConfiguration` (type: `object`):
Proxies to use. Datacenter (the default) is clean and cheap for Spotify's web back end; a fresh session per request spreads the per-IP rate limit.
## Actor input object example
```json
{
"searchQueries": [
"Taylor Swift"
],
"searchType": "artist",
"market": "US",
"resultsPerSearch": 20,
"includeArtistDiscography": false,
"maxDiscographyItems": 50,
"includeRelatedArtists": false,
"enrichArtistContacts": false,
"includeAlbumTracks": true,
"maxTracksPerAlbum": 50,
"includePlaylistTracks": true,
"maxTracksPerPlaylist": 100,
"includeShowEpisodes": true,
"maxEpisodesPerShow": 50,
"maxResults": 100,
"deduplicate": true,
"monitorMode": false,
"monitorKey": "default",
"maxConcurrency": 4,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `results` (type: `string`):
All scraped Spotify records (artists, tracks, albums, playlists, podcasts & episodes) as JSON items in the default dataset.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"searchQueries": [
"Taylor Swift"
],
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"searchQueries": ["Taylor Swift"],
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("scrapesage/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 '{
"searchQueries": [
"Taylor Swift"
],
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call scrapesage/spotify-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=scrapesage/spotify-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Spotify Scraper - Monthly Listeners, Play Counts & Podcasts",
"description": "Scrape Spotify artists, tracks, albums, playlists & podcasts — including monthly listeners, world rank, top cities, exact play counts, followers & artist contact leads. Data the official API hides. No API key, no login. Search or paste URLs, monitor stats over time.",
"version": "0.1",
"x-build-id": "krZKWUfh7UU1gehrk"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/scrapesage~spotify-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-scrapesage-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/scrapesage~spotify-scraper/runs": {
"post": {
"operationId": "runs-sync-scrapesage-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/scrapesage~spotify-scraper/run-sync": {
"post": {
"operationId": "run-sync-scrapesage-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": {
"searchQueries": {
"title": "Search keywords",
"type": "array",
"description": "Things to search Spotify for — an artist, song, album, playlist or podcast name, e.g. Taylor Swift, bohemian rhapsody, lofi beats, The Joe Rogan Experience. Each query returns the chosen Result type below. Leave empty if you only paste URLs.",
"items": {
"type": "string"
}
},
"searchType": {
"title": "Result type (for keyword searches)",
"enum": [
"artist",
"track",
"album",
"playlist",
"podcast",
"episode",
"all"
],
"type": "string",
"description": "What kind of records keyword searches return. Artist = full profile with monthly listeners & play counts (the headline). Track / Album / Playlist = music records. Podcast / Episode = podcast shows & episodes. All mixes every type.",
"default": "artist"
},
"startUrls": {
"title": "Spotify URLs / URIs",
"type": "array",
"description": "Paste any Spotify links or URIs to scrape directly — artists (open.spotify.com/artist/…), tracks, albums, playlists, podcasts (/show/…) or episodes. spotify:artist:… URIs and intl-xx links work too. Used in addition to the search.",
"items": {
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"title": "URL of a web page",
"format": "uri"
}
}
}
},
"market": {
"title": "Market / country",
"type": "string",
"description": "Two-letter country code for availability, podcast catalogs and localized results, e.g. US, GB, DE, BR.",
"default": "US"
},
"resultsPerSearch": {
"title": "Results per search keyword",
"minimum": 1,
"maximum": 100,
"type": "integer",
"description": "How many records to fetch for each keyword (capped by Max results overall).",
"default": 20
},
"includeArtistDiscography": {
"title": "Artists: include full discography",
"type": "boolean",
"description": "Add the artist's album/single/compilation list (title, type, year). Adds one request per artist. Counts are always included.",
"default": false
},
"maxDiscographyItems": {
"title": "Max discography items",
"minimum": 1,
"maximum": 100,
"type": "integer",
"description": "Maximum releases to include when discography is on.",
"default": 50
},
"includeRelatedArtists": {
"title": "Artists: include related artists",
"type": "boolean",
"description": "Add up to 20 related/similar artists (name + id) for discovery and graph-building.",
"default": false
},
"enrichArtistContacts": {
"title": "Artists: enrich contact leads",
"type": "boolean",
"description": "Turn each artist into a B2B lead: when they list their own website, visit it (home + about/contact, max 3 pages) for publicly listed booking/management emails, phones and extra socials, then add a 0–100 lead score. Spotify never exposes emails — this is the only way to get them.",
"default": false
},
"includeAlbumTracks": {
"title": "Albums: include tracklist",
"type": "boolean",
"description": "Include each album's full tracklist with per-track play counts. Turn off for a lighter album record (label, copyrights, totals only).",
"default": true
},
"maxTracksPerAlbum": {
"title": "Max tracks per album",
"minimum": 1,
"maximum": 100,
"type": "integer",
"description": "Cap the tracklist length per album.",
"default": 50
},
"includePlaylistTracks": {
"title": "Playlists: include tracklist",
"type": "boolean",
"description": "Include each playlist's tracks (track, artists, album). Turn off to only get name, owner, follower count & total tracks.",
"default": true
},
"maxTracksPerPlaylist": {
"title": "Max tracks per playlist",
"minimum": 1,
"maximum": 200,
"type": "integer",
"description": "Cap the number of tracks pulled per playlist.",
"default": 100
},
"includeShowEpisodes": {
"title": "Podcasts: include episodes",
"type": "boolean",
"description": "Include a page of a podcast show's episodes (title, description, duration, release date). Turn off for show metadata only.",
"default": true
},
"maxEpisodesPerShow": {
"title": "Max episodes per show",
"minimum": 1,
"maximum": 50,
"type": "integer",
"description": "Cap the number of episodes pulled per podcast show.",
"default": 50
},
"maxResults": {
"title": "Max results",
"minimum": 1,
"type": "integer",
"description": "Maximum number of records to scrape across all searches and URLs.",
"default": 100
},
"deduplicate": {
"title": "Deduplicate records",
"type": "boolean",
"description": "Drop duplicate records that match more than one keyword/URL in the same run.",
"default": true
},
"monitorMode": {
"title": "Monitor mode (only new / changed)",
"type": "boolean",
"description": "Remember each record's key stat across runs in a named key-value store and emit ONLY records that are new or whose stats CHANGED (monthly listeners, play count, followers, episode count). Pair with Apify Schedules to track an artist's growth, a playlist's followers, or a podcast's new episodes over time — it complements the scheduler (the schedule starts the run, monitor mode dedupes against prior runs).",
"default": false
},
"monitorKey": {
"title": "Monitor key",
"type": "string",
"description": "Names the monitor's memory store so you can run several independent monitors (e.g. one per artist roster or playlist set). Reuse the same key to keep tracking the same feed.",
"default": "default"
},
"maxConcurrency": {
"title": "Max concurrency",
"minimum": 1,
"maximum": 8,
"type": "integer",
"description": "Parallel requests. Each uses a fresh proxy IP to spread Spotify's per-IP rate limit; keep this modest.",
"default": 4
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Proxies to use. Datacenter (the default) is clean and cheap for Spotify's web back end; a fresh session per request spreads the per-IP rate limit.",
"default": {
"useApifyProxy": true
}
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```