Pricing

from $1.50 / 1,000 dataset items

Try for free

Go to Apify Store

Spotify Scraper - Artists, Playlists & Tracks

Try for free

Scrape public Spotify artists, tracks, albums, playlists and podcasts. Get available listener and play counts, discover artists and track playlist or catalog changes. Export JSON or CSV and schedule repeat runs.

Pricing

from $1.50 / 1,000 dataset items

Rating

0.0

(0)

Developer

Fetch Finch

Actor stats

Bookmarked

Total users

Monthly active users

10 days ago

Last modified

Categories

Social media

Developer tools

Automation

You can access the Spotify Scraper - Artists, Playlists & Tracks programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.1",
    "x-build-id": "LchwMpLc0pT0r2wSf"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/fetchfinch~spotify-public-catalog-metadata/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-fetchfinch-spotify-public-catalog-metadata",
        "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/fetchfinch~spotify-public-catalog-metadata/runs": {
      "post": {
        "operationId": "runs-sync-fetchfinch-spotify-public-catalog-metadata",
        "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/fetchfinch~spotify-public-catalog-metadata/run-sync": {
      "post": {
        "operationId": "run-sync-fetchfinch-spotify-public-catalog-metadata",
        "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": "Run mode",
            "enum": [
              "snapshot",
              "monitor",
              "playlist_intelligence",
              "discover"
            ],
            "type": "string",
            "description": "Snapshot returns current records. Monitor tracks changes. Playlist intelligence adds graph and composition records. Discover runs an artist-focused enriched search.",
            "default": "snapshot"
          },
          "stateStoreName": {
            "title": "Monitor state store",
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "type": "string",
            "description": "Named Apify Key-Value Store used to keep the previous successful snapshot in monitor mode.",
            "default": "spotify-catalog-monitor"
          },
          "historyDatasetName": {
            "title": "History dataset",
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "type": "string",
            "description": "Named Apify Dataset used to append successful snapshots in monitor mode.",
            "default": "spotify-catalog-history"
          },
          "onlyChanges": {
            "title": "Output changes only",
            "type": "boolean",
            "description": "In monitor mode, omit current snapshot records from the default dataset and return only change records.",
            "default": false
          },
          "changePreset": {
            "title": "Change preset",
            "enum": [
              "all_changes",
              "playlist_changes",
              "metrics_only"
            ],
            "type": "string",
            "description": "Choose which monitor events should be emitted after the first snapshot.",
            "default": "all_changes"
          },
          "ignoredFields": {
            "title": "Ignored fields",
            "maxItems": 50,
            "type": "array",
            "description": "Optional exact JSON field paths to ignore during monitor comparisons.",
            "items": {
              "type": "string"
            }
          },
          "metricThresholdPercent": {
            "title": "Metric threshold (%)",
            "minimum": 0,
            "maximum": 100,
            "type": "number",
            "description": "Ignore monitored numeric metric changes smaller than this percentage.",
            "default": 0
          },
          "maxGraphNodes": {
            "title": "Maximum graph nodes",
            "minimum": 1,
            "maximum": 10000,
            "type": "integer",
            "description": "Upper bound for node records emitted by playlist intelligence mode.",
            "default": 1000
          },
          "rankBy": {
            "title": "Discovery ranking",
            "enum": [
              "monthly_listeners",
              "followers",
              "release_count",
              "top_track_count"
            ],
            "type": "string",
            "description": "Artist field used to rank enriched discovery results.",
            "default": "monthly_listeners"
          },
          "minMonthlyListeners": {
            "title": "Minimum monthly listeners",
            "minimum": 0,
            "type": "integer",
            "description": "In discover mode, keep only artists at or above this monthly listener count."
          },
          "maxMonthlyListeners": {
            "title": "Maximum monthly listeners",
            "minimum": 0,
            "type": "integer",
            "description": "In discover mode, keep only artists at or below this monthly listener count."
          },
          "minFollowers": {
            "title": "Minimum followers",
            "minimum": 0,
            "type": "integer",
            "description": "In discover mode, keep only artists at or above this follower count."
          },
          "maxFollowers": {
            "title": "Maximum followers",
            "minimum": 0,
            "type": "integer",
            "description": "In discover mode, keep only artists at or below this follower count."
          },
          "minReleases": {
            "title": "Minimum releases",
            "minimum": 0,
            "type": "integer",
            "description": "In discover mode, keep only artists with at least this many releases."
          },
          "targets": {
            "title": "Spotify URLs, URIs, or IDs",
            "maxItems": 1000,
            "type": "array",
            "description": "Spotify URLs or spotify:type:id URIs. Raw 22-character IDs are also accepted when Target type is selected.",
            "items": {
              "type": "string"
            }
          },
          "targetType": {
            "title": "Target type",
            "enum": [
              "auto",
              "track",
              "album",
              "artist",
              "playlist",
              "show",
              "episode"
            ],
            "type": "string",
            "description": "Use Auto for URLs and URIs. Select an entity type when providing raw Spotify IDs.",
            "default": "auto"
          },
          "searchQueries": {
            "title": "Search queries",
            "maxItems": 50,
            "type": "array",
            "description": "Optional public Spotify catalog searches. Search results are sparse unless Enrich search results is enabled.",
            "items": {
              "type": "string"
            }
          },
          "searchTypes": {
            "title": "Search entity types",
            "type": "array",
            "description": "Entity sections to request for each search query.",
            "default": [
              "track",
              "album",
              "artist",
              "playlist",
              "show",
              "episode"
            ],
            "items": {
              "type": "string"
            }
          },
          "enrichSearchResults": {
            "title": "Enrich search results",
            "type": "boolean",
            "description": "Fetch each search hit again as a full entity. This is slower and creates more Spotify requests.",
            "default": false
          },
          "maxSearchResults": {
            "title": "Results per search section",
            "minimum": 1,
            "maximum": 50,
            "type": "integer",
            "description": "Maximum results per entity type and query.",
            "default": 20
          },
          "maxItems": {
            "title": "Maximum output records",
            "minimum": 1,
            "maximum": 5000,
            "type": "integer",
            "description": "Maximum current snapshot records, including error records. Monitor mode may additionally emit one change record per successful entity.",
            "default": 100
          },
          "maxTracks": {
            "title": "Maximum playlist tracks",
            "minimum": 1,
            "maximum": 500,
            "type": "integer",
            "description": "Maximum tracks loaded for each playlist. Album tracklists are fetched by the library as provided by Spotify.",
            "default": 100
          },
          "maxEpisodes": {
            "title": "Maximum show episodes",
            "minimum": 1,
            "maximum": 1000,
            "type": "integer",
            "description": "Maximum episodes loaded for each podcast show.",
            "default": 50
          },
          "maxConcurrency": {
            "title": "Maximum concurrency",
            "minimum": 1,
            "maximum": 10,
            "type": "integer",
            "description": "Number of entity pipelines allowed to run concurrently. Lower values reduce request pressure.",
            "default": 5
          },
          "timeoutSecs": {
            "title": "Request timeout (seconds)",
            "minimum": 5,
            "maximum": 60,
            "type": "integer",
            "description": "Timeout applied to each catalog request.",
            "default": 15
          },
          "proxyConfiguration": {
            "title": "Proxy configuration",
            "type": "object",
            "description": "Optional Apify Proxy configuration for Spotify requests.",
            "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Spotify Scraper - Artists, Playlists & Tracks OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Spotify Scraper - Artists, Playlists & Tracks from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Spotify Scraper - Artists, Playlists & Tracks API in Python

Spotify Scraper - Artists, Playlists & Tracks API in JavaScript

Spotify Scraper - Artists, Playlists & Tracks API through CLI

Spotify Scraper - Artists, Playlists & Tracks API

Spotify Scraper — Artists, Tracks & Playlists

khadinakbar/spotify-all-in-one-scraper

Scrape Spotify artists, albums, tracks, playlists, podcasts, episodes, and search with play counts and monthly listeners. HTTP-only, no API key. MCP/API-ready.

Khadin Akbar

Spotify Scraper — Tracks, Artists, Albums & Playlists

hipersoft/spotify-scraper

Search Spotify and scrape public metadata for tracks, artists, albums and playlists: names, artists, popularity, followers, genres, release dates, duration, ISRC, preview URL and more. No Spotify login or API key required. For music research, catalogs and analytics.

hiper soft

Spotify Scraper - Tracks, Albums, Artists & Playlists

logiover/spotify-scraper

Unofficial Spotify API — no key, no login. Search tracks, albums, artists, playlists, shows & episodes; pull artist discographies, album & playlist tracks, and new releases. Export Spotify data (popularity, ISRC, followers, durations) to JSON, CSV or Excel.

Logiover

Spotify Scraper

solidcode/spotify-scraper

[💰 $2.5 / 1K] Extract Spotify artists, albums, tracks, playlists, and podcasts. Search by keyword or paste links to get listeners, play counts, track lists, episodes, and more.

SolidCode

Spotify Scraper | All-In-One

fatihtahta/spotify-scraper

Scrape Spotify and export clean data for tracks, artists, albums, playlists, podcasts and episodes. Get images, artists, links, release dates, popularity, duration and more. Great for discovery tools, trend tracking and catalog audits.

Fatih Tahta

106

Spotify Scraper—Play Counts, Tracks, Artists, Playlists, Lyrics

eduair94/spotify-scraper

Spotify play counts (stream counts) for any track, album or artist's top tracks, plus tracks, artists, albums, playlists, lyrics, credits, concerts and charts. 50+ categories, pay per result.

Eduardo Airaudo

5.0

Spotify Scraper

fetch_cat/spotify-scraper

Export public Spotify artists, tracks, albums, playlists, podcasts, episodes, audiobooks, images, markets, and public metrics. Direct URLs need no API key.

Hanna Nosova

Spotify Scraper

cravl/spotify-scraper

Scrape Spotify tracks, albums, artists, playlists, and episodes via the guest embed API: names, artists, release dates, durations, previews, cover art, and track lists.

Cravl

Spotify Scraper

automation-lab/spotify-scraper

Extract Spotify artists, tracks, albums, and playlists from search terms or URLs. Get monthly listeners, play counts, followers, world rank, biographies, and top tracks — no API key needed.

Automation Lab

587

Spotify Scraper

magicfingers/spotify-scraper

Scrape Spotify podcasts, music tracks, artists, albums, and playlists. Search by keyword or provide direct URLs. Extract episodes, top tracks, discography, monthly listeners, and more.