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

\[💰 $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.

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

## Pricing

from $2.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

Pull artists, albums, tracks, playlists, and podcasts from Spotify at scale — monthly listeners, global world rank, follower counts, play counts, biographies, related artists, and full track and episode lists with ISO release dates and formatted durations. No login, no API keys, no app registration. Built for music-data analysts, playlist curators, A&R scouts, and app builders who need clean, structured Spotify catalog data without juggling developer credentials or rate-limited tokens.

### Why This Scraper?

- **Five entity types from one input** — tracks, artists, albums, playlists, and podcasts/shows, all from a single keyword search or a pasted link.
- **Artist intelligence built in** — monthly listeners, total followers, global world rank, genres, biography, related artists, and external links on every artist.
- **Podcast & episode support** — search shows by keyword or paste a show link and pull every episode with publish dates and durations. The leading competitor does not do podcasts at all.
- **Up to 1,000 search results per keyword** — page deep into Spotify's search index with smooth pagination and automatic de-duplication.
- **Per-track play counts** — real listen counts on album tracks and artist top tracks, not just titles.
- **Track and episode child rows linked to their parent** — every track or episode is its own row carrying a `parentId`, so a playlist's contents land in a table ready to filter, sort, and join.
- **Deep playlist pagination** — go past the old ~100-track embed ceiling all the way up to Spotify's 10,000-track playlist limit.
- **Paste any Spotify link** — full `open.spotify.com` links, short `spotify.link` URLs, and `spotify:` URIs are all accepted, with the entity type detected automatically.
- **Audio previews on podcast episodes** — playable preview-clip URLs on every episode row, plus the largest available cover or profile image on every record.

### Use Cases

**Music Analytics & A&R**
- Track an artist's monthly listeners and global world rank over time
- Compare play counts across an album's tracks to spot breakout songs
- Discover rising acts through related-artist chains
- Benchmark follower growth across a roster of artists

**Playlist Research & Curation**
- Export the full track list of any editorial or user playlist
- Find which artists dominate a popular playlist
- Audit your own playlists for duplicates or stale tracks
- Build seed lists for recommendation engines

**Podcast Intelligence**
- Pull a show's entire back catalog of episodes with publish dates
- Track release cadence and episode durations across competing shows
- Build a searchable index of episodes by topic or keyword

**Catalog & Metadata Enrichment**
- Enrich an internal music database with Spotify IDs, cover art, and release dates
- Resolve track and album metadata in bulk from a list of links
- Feed structured catalog data into dashboards and reporting tools

**App & Product Development**
- Power music-discovery features without managing OAuth tokens
- Seed a new app with real catalog metadata for testing
- Build search and lookup tools on top of a clean dataset

### Getting Started

#### Simple Keyword Search

One keyword, the default 50 results:

```json
{
    "searchTerms": ["Taylor Swift"],
    "searchType": "artists"
}
````

#### Search Podcasts Without Track Lists

Find shows by keyword and keep runs lean by skipping episode lists:

```json
{
    "searchTerms": ["true crime", "history"],
    "searchType": "podcasts",
    "includeTracks": false,
    "maxResults": 25
}
```

#### Scrape Specific Links (Advanced)

Paste any mix of artist, album, playlist, and track links — the type of each is detected automatically — and cap each parent at 200 tracks:

```json
{
    "urls": [
        "https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02",
        "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M",
        "spotify:album:1NAmidJlEaVgA3MpcPFYGq"
    ],
    "includeTracks": true,
    "maxTracksPerItem": 200,
    "maxResults": 0
}
```

### Input Reference

#### Search by Keyword

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `[]` | Keywords to look up on Spotify, such as "Taylor Swift", "lofi beats", or "true crime". Each keyword returns results of the type you pick below. |
| `searchType` | string | `Tracks` | What kind of Spotify results to return for your keywords. Options: Tracks, Artists, Albums, Playlists, Podcasts & Shows. |

#### Scrape Specific Links

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `urls` | string\[] | `[]` | Paste Spotify links to scrape directly — artists, albums, tracks, playlists, podcasts/shows, or episodes. Works with open.spotify.com links, short links, and spotify: links. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `50` | Maximum number of items to collect per keyword search, and the maximum number of links to process. Set to 0 for no limit. |
| `includeTracks` | boolean | `true` | For albums, playlists, artists, and podcasts, also collect the individual tracks (or episodes). Turn this off to get only the main record and keep runs lean. |
| `maxTracksPerItem` | integer | `100` | Maximum number of tracks or episodes to collect from each album, playlist, artist, or podcast. Set to 0 for all. Useful for very large playlists, which can hold thousands of tracks. |

### Output

Every row carries a `recordType` field — `artist`, `album`, `playlist`, `podcast`, `track`, or `episode` — so you can filter cleanly downstream. Parents (artist, album, playlist, podcast) and their child `track`/`episode` rows are saved to separate dataset views. Every row includes `id`, `name`, `url`, `imageUrl`, and a `scrapedAt` ISO 8601 timestamp.

#### Artist (`recordType: "artist"`)

```json
{
    "recordType": "artist",
    "id": "06HL4z0CvFAxyc27GXpf02",
    "name": "Taylor Swift",
    "url": "https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02",
    "imageUrl": "https://i.scdn.co/image/ab6761610000e5eb...",
    "monthlyListeners": 91245031,
    "followers": 119284756,
    "worldRank": 3,
    "biography": "Taylor Swift is a singer-songwriter...",
    "genres": ["pop", "country pop"],
    "externalLinks": [{ "name": "Instagram", "url": "https://instagram.com/taylorswift" }],
    "relatedArtists": [{ "id": "1McMsnEElThX1knmY4oliG", "name": "Olivia Rodrigo" }],
    "scrapedAt": "2026-06-28T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `monthlyListeners` | number | Monthly listener count |
| `followers` | number | Total follower count |
| `worldRank` | number | Global popularity rank (may be null) |
| `biography` | string | Artist biography text |
| `genres` | string\[] | Associated genres (often empty even for major artists) |
| `externalLinks` | object\[] | Social/web links as `{name, url}` |
| `relatedArtists` | object\[] | Similar artists as `{id, name}` |

#### Album (`recordType: "album"`)

```json
{
    "recordType": "album",
    "id": "1NAmidJlEaVgA3MpcPFYGq",
    "name": "Lover",
    "url": "https://open.spotify.com/album/1NAmidJlEaVgA3MpcPFYGq",
    "imageUrl": "https://i.scdn.co/image/ab67616d0000b273...",
    "artists": "Taylor Swift",
    "releaseDate": "2019-08-23T00:00:00Z",
    "owner": "Republic Records",
    "trackCount": 18,
    "scrapedAt": "2026-06-28T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `artists` | string | Album artist name(s), comma-separated |
| `releaseDate` | string | ISO 8601 release date |
| `owner` | string | Record label |
| `trackCount` | number | Number of tracks on the album |

#### Playlist (`recordType: "playlist"`)

```json
{
    "recordType": "playlist",
    "id": "37i9dQZF1DXcBWIGoYBM5M",
    "name": "Today's Top Hits",
    "url": "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M",
    "imageUrl": "https://i.scdn.co/image/ab67706f00000002...",
    "owner": "Spotify",
    "description": "The hottest tracks right now.",
    "followers": 34829174,
    "trackCount": 50,
    "scrapedAt": "2026-06-28T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `owner` | string | Playlist owner's display name |
| `description` | string | Playlist description |
| `followers` | number | Playlist follower count |
| `trackCount` | number | Number of tracks in the playlist |

#### Podcast / Show (`recordType: "podcast"`)

```json
{
    "recordType": "podcast",
    "id": "4rOoJ6Egrf8K2IrywzwOMk",
    "name": "The Joe Rogan Experience",
    "url": "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk",
    "imageUrl": "https://i.scdn.co/image/ab6765630000ba8a...",
    "owner": "Joe Rogan",
    "description": "The official podcast of comedian Joe Rogan.",
    "trackCount": 2200,
    "scrapedAt": "2026-06-28T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `owner` | string | Publisher name |
| `description` | string | Show description |
| `trackCount` | number | Total number of episodes |

#### Track (`recordType: "track"`)

Returned as a parent (from a track search or track link) and as a child row inside albums, playlists, and artist top tracks. Child rows add `parentId`, `parentName`, and `parentType`; playlist children also add `addedAt`.

```json
{
    "recordType": "track",
    "id": "1BxfuPKGuaTgP7aM0Bbdwr",
    "name": "Cruel Summer",
    "url": "https://open.spotify.com/track/1BxfuPKGuaTgP7aM0Bbdwr",
    "imageUrl": "https://i.scdn.co/image/ab67616d0000b273...",
    "artists": "Taylor Swift",
    "albumName": "Lover",
    "releaseDate": "2019-08-23T00:00:00Z",
    "trackNumber": 2,
    "duration": 178426,
    "durationFormatted": "2:58",
    "isExplicit": false,
    "playCount": 1842930571,
    "parentId": "1NAmidJlEaVgA3MpcPFYGq",
    "parentName": "Lover",
    "parentType": "album",
    "scrapedAt": "2026-06-28T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `artists` | string | Track artist name(s), comma-separated |
| `albumName` | string | Name of the track's album |
| `releaseDate` | string | ISO 8601 release date (parent track rows) |
| `trackNumber` | number | Position on the album |
| `duration` | number | Length in milliseconds |
| `durationFormatted` | string | Human-readable length, e.g. "2:58" |
| `isExplicit` | boolean | Explicit-content flag |
| `playCount` | number | Total play count (may be null) |
| `parentId` / `parentName` / `parentType` | string | The album, playlist, or artist this track belongs to (child rows only) |
| `addedAt` | string | When the track was added to the playlist (playlist children only) |

#### Episode (`recordType: "episode"`)

Returned as a parent (from an episode link) and as a child row inside podcasts. Child rows add `parentId`, `parentName`, and `parentType`.

```json
{
    "recordType": "episode",
    "id": "512ojhOuo1ktJprKbVcKyQ",
    "name": "#2000 - Comedy & Conversation",
    "url": "https://open.spotify.com/episode/512ojhOuo1ktJprKbVcKyQ",
    "imageUrl": "https://i.scdn.co/image/ab6765630000ba8a...",
    "owner": "The Joe Rogan Experience",
    "description": "A wide-ranging conversation...",
    "releaseDate": "2026-06-15T00:00:00Z",
    "duration": 10845000,
    "durationFormatted": "3:00:45",
    "isExplicit": true,
    "audioPreviewUrl": "https://podz-content.spotifycdn.com/...",
    "parentId": "4rOoJ6Egrf8K2IrywzwOMk",
    "parentName": "The Joe Rogan Experience",
    "parentType": "podcast",
    "scrapedAt": "2026-06-28T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `owner` | string | Publishing show name |
| `description` | string | Episode description |
| `releaseDate` | string | ISO 8601 publish date |
| `duration` | number | Length in milliseconds |
| `durationFormatted` | string | Human-readable length, e.g. "3:00:45" |
| `isExplicit` | boolean | Explicit-content flag |
| `audioPreviewUrl` | string | Preview clip URL (may be null) |
| `parentId` / `parentName` / `parentType` | string | The podcast this episode belongs to (child rows only) |

### Tips for Best Results

- **Search caps at 1,000 results per keyword.** Spotify's own search index returns at most 1,000 hits for any term. To go beyond that, split a broad search into several narrower keywords (e.g. by genre or year).
- **Use `includeTracks` and `maxTracksPerItem` to control cost.** A single big playlist can return thousands of track rows. Turn `includeTracks` off when you only need parent records, or set `maxTracksPerItem` to keep large playlists and long-running shows in check.
- **Match `searchType` to what you want.** A keyword like "lofi" returns very different results as Tracks, Playlists, or Podcasts — pick the type before you run.
- **Paste links for precision.** When you already know the exact artist, album, or playlist, pasting links is faster and more reliable than searching by keyword.
- **Mix links and searches freely.** Keyword searches and pasted links run in the same job, so you can survey a topic and pull specific items in one go.
- **Set `maxResults` to 0 for everything.** Leave it at 0 to collect every available item (still bounded by Spotify's 1,000-per-search cap), or keep it small for quick test runs.
- **Genres and world rank can be empty.** Spotify leaves these blank for some artists, so treat `genres` and `worldRank` as optional when building reports.

### Pricing

**From $2.50 per 1,000 results** — flat, per-result pricing with no surprises. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.45 | $0.39 | $0.32 | $0.25 |
| 1,000 | $4.50 | $3.85 | $3.15 | $2.50 |
| 10,000 | $45.00 | $38.50 | $31.50 | $25.00 |
| 100,000 | $450.00 | $385.00 | $315.00 | $250.00 |

A "result" is any row in the output dataset — every parent (artist, album, playlist, podcast) **and** every child track or episode each count as one result, so a large playlist with its full track list returns many results. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate music research, catalog analysis, playlist curation, and product development using publicly available Spotify data. Users are responsible for complying with applicable laws and Spotify's terms of service. Do not use extracted data for spam, harassment, or any illegal purpose, and respect the rights of artists, creators, and rights holders when using catalog metadata. </content> </invoke>

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to look up on Spotify, such as 'Taylor Swift', 'lofi beats', or 'true crime'. Each keyword returns results of the type you pick below.

## `searchType` (type: `string`):

What kind of Spotify results to return for your keywords.

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

Paste Spotify links to scrape directly — artists, albums, tracks, playlists, podcasts/shows, or episodes. Works with open.spotify.com links, short links, and spotify: links. Example: https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02

## `maxResults` (type: `integer`):

Maximum number of items to collect per keyword search, and the maximum number of links to process. Set to 0 for no limit.

## `includeTracks` (type: `boolean`):

For albums, playlists, artists, and podcasts, also collect the individual tracks (or episodes). Turn this off to get only the main record and keep runs lean.

## `maxTracksPerItem` (type: `integer`):

Maximum number of tracks or episodes to collect from each album, playlist, artist, or podcast. Set to 0 for all. Useful for very large playlists, which can hold thousands of tracks.

## Actor input object example

```json
{
  "searchTerms": [],
  "searchType": "tracks",
  "urls": [],
  "maxResults": 50,
  "includeTracks": true,
  "maxTracksPerItem": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Every record from the run in one place — parents and their tracks/episodes — distinguished by `recordType`.

## `items` (type: `string`):

Parent records only: artists (with monthly listeners, followers, genres), albums, playlists, and podcasts.

## `tracks` (type: `string`):

Individual tracks and podcast episodes, each linked to its parent. Present only when 'Include Track Lists' is enabled.

# 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 = {
    "searchTerms": [],
    "searchType": "tracks",
    "urls": [],
    "maxResults": 50,
    "includeTracks": true,
    "maxTracksPerItem": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchTerms": [],
    "searchType": "tracks",
    "urls": [],
    "maxResults": 50,
    "includeTracks": True,
    "maxTracksPerItem": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchTerms": [],
  "searchType": "tracks",
  "urls": [],
  "maxResults": 50,
  "includeTracks": true,
  "maxTracksPerItem": 100
}' |
apify call solidcode/spotify-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Scraper",
        "description": "[💰 $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.",
        "version": "1.0",
        "x-build-id": "n4gCpAu7PL3HyoBvf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~spotify-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~spotify-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~spotify-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to look up on Spotify, such as 'Taylor Swift', 'lofi beats', or 'true crime'. Each keyword returns results of the type you pick below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Search For",
                        "enum": [
                            "tracks",
                            "artists",
                            "albums",
                            "playlists",
                            "podcasts"
                        ],
                        "type": "string",
                        "description": "What kind of Spotify results to return for your keywords.",
                        "default": "tracks"
                    },
                    "urls": {
                        "title": "Spotify Links",
                        "type": "array",
                        "description": "Paste Spotify links to scrape directly — artists, albums, tracks, playlists, podcasts/shows, or episodes. Works with open.spotify.com links, short links, and spotify: links. Example: https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of items to collect per keyword search, and the maximum number of links to process. Set to 0 for no limit.",
                        "default": 50
                    },
                    "includeTracks": {
                        "title": "Include Track Lists",
                        "type": "boolean",
                        "description": "For albums, playlists, artists, and podcasts, also collect the individual tracks (or episodes). Turn this off to get only the main record and keep runs lean.",
                        "default": true
                    },
                    "maxTracksPerItem": {
                        "title": "Max Tracks Per Item",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of tracks or episodes to collect from each album, playlist, artist, or podcast. Set to 0 for all. Useful for very large playlists, which can hold thousands of tracks.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```