# Spotify Playlists Search and Scraper 🎧 (`apiharvest/spotify-playlists-search-and-scraper`) Actor

🎧 Scrape  playlists' full paginated track listings, owner profile, follower count, description, cover art & collaborative status. Enable Fetch Details to get every track in the playlist, not just search previews. Complete playlist data same as Spotify app ✨Spotify Playlists Search and Scraper 🎧

- **URL**: https://apify.com/apiharvest/spotify-playlists-search-and-scraper.md
- **Developed by:** [APIHarvest](https://apify.com/apiharvest) (community)
- **Categories:** Automation, Developer tools, Social media
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 result scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Playlists Scraper — Search & Scrape Complete Spotify Playlist Data | Best Spotify Scraper

### What is the Spotify Playlists Scraper?

The **Spotify Playlists Scraper** is a production-ready Apify actor built to search and scrape Spotify playlists at scale. This Spotify playlists scraper extracts complete playlist metadata including full track listings, owner information, follower counts, and descriptions — directly from Spotify. No Spotify API key, no login credentials, no developer account required.

Unlike the official Spotify Web API which requires OAuth and imposes rate limits, this Spotify playlists scraper uses Spotify's internal API to pull rich, structured playlist data. The Spotify playlists scraper automatically handles token rotation, proxy management, and retry logic for reliable scraping.

---

### How Does This Spotify Playlists Scraper Work?

This Spotify playlists scraper operates in **two modes** that are auto-detected from your input:

#### Mode 1: Search Spotify Playlists by Keyword

Enter one or more keywords and the Spotify playlists scraper searches Spotify's catalog for matching playlists. You can search by mood, genre, activity, or any keyword. The Spotify playlists scraper returns structured results for every matching Spotify playlist.

**Example keywords:** `"workout"`, `"chill vibes"`, `"study music"`, `"road trip"`, `"90s hits"`, `"coding focus"`

#### Mode 2: Scrape Specific Spotify Playlists by URI or URL

Already have Spotify playlist links? Paste them directly. The Spotify playlists scraper accepts both URI format (`spotify:playlist:37i9dQZF1DXcBWIGoYBM5M`) and URL format (`https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M`). Each Spotify playlist URI is resolved to its full metadata with track listings.

#### Auto-Detection

The Spotify playlists scraper automatically detects the mode:

- **Fill Search Keywords** → Spotify playlists search mode activates
- **Fill Spotify Playlist URIs / URLs** → Spotify playlist details mode activates
- **Fill both** → The Spotify playlists scraper runs search first, then fetches details for the URIs

#### Detail Enrichment (Search Mode)

When searching, the Spotify playlists scraper returns basic search results by default. Enable **Fetch Full Playlist Details** to enrich each search result with complete metadata and track listings.

---

### Input Configuration

| Field | Mode | Description | Default |
|-------|------|-------------|---------|
| **Search Keywords** | Search | One or more keywords to search Spotify playlists. Each keyword runs as a separate query. | — |
| **Spotify Playlist URIs / URLs** | Details | One or more `spotify:playlist:ID` URIs or URLs | — |
| **Proxy Country** | Both | Residential proxy country (50+ available). US recommended for best Spotify playlists scraper results. | US |
| **Search Offset** | Search | Starting position for search pagination. | 0 |
| **Search Limit** | Search | Maximum number of Spotify playlists to return per keyword. | 30 |
| **Top Results Count** | Search | Number of top-ranked Spotify playlists. | 20 |
| **Fetch Full Playlist Details** | Search | When ON, enriches each Spotify playlist search result with full metadata. | OFF |
| **Track List Offset** | Details | Starting position for the Spotify playlist track list. | 0 |
| **Track List Limit** | Details | Maximum tracks to return from each Spotify playlist. | 50 |

#### Understanding Filters & Toggles

| Toggle / Filter | Default | What Happens When ON | What You Miss When OFF |
|----------------|---------|---------------------|----------------------|
| **Fetch Full Playlist Details** | OFF | Each search result is enriched with complete metadata: full paginated track listings, follower count, owner profile, playlist description, collaborative status, and all cover art variants. | You only get basic search data — playlist name, owner, image, track count, and URI. No actual track list, no follower count, no description. |
| **Track List Offset** | 0 | Start position in the playlist's track list. Use for paginating playlists with 100+ tracks. | — |
| **Track List Limit** | 25 | Max tracks to return from each playlist. | — |
| **Search Limit** | 30 | Controls how many playlist results you get per keyword. | — |
| **Search Offset** | 0 | Skip results for pagination. | — |

> **💡 Tip:** When using Playlist URIs/URLs (Get Details mode), full details are **always** fetched automatically — the Fetch Full Playlist Details toggle only applies to Search mode.

#### URL Validation

The Spotify playlists scraper validates every URI. If you paste a track, album, or artist URI, it logs which actor to use instead.

---

### Output Data Format

Every Spotify playlist scraped by this Spotify playlists scraper is pushed as a structured JSON object.

#### Search Result Example

```json
{
    "query": "workout",
    "uri": "spotify:playlist:37i9dQZF1DXcBWIGoYBM5M",
    "name": "Today's Top Hits",
    "description": "The biggest songs of the moment.",
    "owner": {"name": "Spotify"},
    "images": {"items": [{"sources": [{"url": "https://i.scdn.co/image/..."}]}]}
}
````

#### Full Detail Example (Get Details mode or Fetch Details ON)

```json
{
    "uri": "spotify:playlist:37i9dQZF1DXcBWIGoYBM5M",
    "name": "Today's Top Hits",
    "description": "The biggest songs of the moment. Cover: Sabrina Carpenter.",
    "owner": {"name": "Spotify", "uri": "spotify:user:spotify"},
    "followers": 35000000,
    "totalCount": 50,
    "images": {"items": [{"sources": [{"url": "https://i.scdn.co/image/...", "width": 640}]}]},
    "content": {
        "totalCount": 50,
        "items": [
            {
                "itemV2": {
                    "data": {
                        "name": "Espresso",
                        "uri": "spotify:track:...",
                        "artists": {"items": [{"profile": {"name": "Sabrina Carpenter"}}]},
                        "albumOfTrack": {"name": "Espresso"},
                        "duration": {"totalMilliseconds": 175000},
                        "playcount": "1234567890"
                    }
                },
                "addedAt": {"isoString": "2024-06-15T00:00:00Z"},
                "addedBy": {"data": {"name": "Spotify"}}
            }
        ]
    }
}
```

The Spotify playlists scraper returns rich data including every track with its artist, album, play count, and when it was added to the Spotify playlist.

***

### Step-by-Step Tutorial

#### How to Search Spotify Playlists

1. Go to the **Spotify Playlists Scraper** actor page on Apify
2. Enter keywords like `"workout"`, `"chill"`, `"study"`, `"party"`
3. Set **Proxy Country** to US (recommended)
4. Adjust **Search Limit** for more or fewer Spotify playlists per keyword
5. (Optional) Turn on **Fetch Full Playlist Details** for track listings
6. Set your **spending limit** and click **Start**
7. Download results from the Dataset tab

#### How to Scrape Specific Spotify Playlists

1. Copy Spotify playlist URIs or URLs (right-click playlist → Share → Copy Link)
2. Paste them into the **Spotify Playlist URIs / URLs** field
3. Set **Track List Limit** to control how many tracks per Spotify playlist
4. Click **Start** — each Spotify playlist URI is resolved to full metadata

***

### Common Use Cases for This Spotify Scraper (Playlists)

#### Music Marketing & Playlist Pitching

Discover Spotify playlists in your genre for pitching songs. The Spotify playlists scraper lets you search by mood, genre, or activity to find the most relevant playlists with follower counts.

#### Playlist Monitoring

Schedule the Spotify playlists scraper to run daily or weekly and track how Spotify playlists change over time — new tracks added, tracks removed, follower growth.

#### Competitive Analysis

Compare editorial vs. user-generated Spotify playlists. The Spotify playlists scraper reveals which tracks appear across multiple playlists and how often playlists are updated.

#### Content Curation

Find inspiration for your own playlists by scraping popular Spotify playlists in your niche. Export track lists and use them as starting points.

#### Market Research

Analyze Spotify playlist trends to understand what listeners want. The Spotify playlists scraper gives you data on playlist categories, sizes, and follower engagement.

#### Data Science & ML

Build recommendation models using Spotify playlist composition data. The Spotify playlists scraper outputs structured data ready for analysis pipelines.

***

### Why Choose This Spotify Scraper Over Others?

Most Spotify scrapers on Apify return incomplete or reformatted data — missing fields, simplified structures, or outdated endpoints. This spotify scraper is different. It delivers **every single data field** that Spotify provides internally — the exact same data the real Spotify app uses.

| Feature | This Spotify Scraper | Other Actors on Apify |
|---------|---------------------|----------------------|
| **Data completeness** | Every field Spotify returns — full track listings, owner profiles, follower counts, playlist descriptions, and cover art images | Partial data, missing key fields |
| **Authentication** | No API key, no login, no developer account | Often require Spotify API credentials |
| **Rate limits** | No limits — automatic token rotation | Restricted by official API quotas |
| **Data structure** | Raw Spotify format — identical to real Spotify app | Reformatted, simplified, or flattened |
| **Proxy support** | 50+ residential proxy countries | Limited or no proxy options |
| **Pricing** | Pay per result — you only pay for data delivered | Flat fees, subscriptions, or usage caps |
| **Reliability** | Auto-adapts to Spotify API changes — always up to date | Hardcoded endpoints that break on updates |

> **Bottom line:** If Spotify shows it, this spotify scraper extracts it. No other Spotify playlist actor on Apify gives you this level of complete, production-ready data.

### Frequently Asked Questions

**Q: Does this Spotify playlists scraper require a Spotify account?**
A: No. The Spotify playlists scraper works without any authentication.

**Q: Can I get all tracks from a large Spotify playlist?**
A: Yes. Increase the **Track List Limit** or use multiple runs with different offsets for very large Spotify playlists.

**Q: Can I see when tracks were added to a Spotify playlist?**
A: Yes. The `addedAt` field in the Spotify playlists scraper output shows the exact date and time each track was added.

**Q: Is there a limit on how many Spotify playlists I can scrape?**
A: No hard limit. The Spotify playlists scraper processes as many as your spending limit allows.

**Q: Can I search for editorial Spotify playlists only?**
A: The Spotify playlists scraper returns all matching playlists. You can filter results by owner (e.g., owner = "Spotify") to find editorial playlists.

**Q: How fast is this Spotify playlists scraper?**
A: Search is fast (seconds). Detail fetching processes each Spotify playlist sequentially — a few seconds per playlist.

***

### Integrations

- **Google Sheets** — Auto-export Spotify playlist data to spreadsheets
- **Webhooks** — Trigger workflows with Spotify playlist data
- **REST API** — Access results programmatically
- **Zapier / Make** — Connect to 5000+ apps

***

### Related Spotify Scrapers by apiharvest

| Actor | Description |
|-------|-------------|
| [Spotify Tracks Scraper](https://apify.com/apiharvest/spotify-tracks-search-and-scraper) | Search & scrape Spotify track metadata with play counts |
| [Spotify Albums Scraper](https://apify.com/apiharvest/spotify-albums-search-and-scraper) | Search & scrape Spotify album metadata with track listings |
| [Spotify Artists Scraper](https://apify.com/apiharvest/spotify-artists-search-and-scraper) | Search & scrape Spotify artist profiles, discography, related artists |
| [Spotify Genres Scraper](https://apify.com/apiharvest/spotify-genres-search-and-scraper) | Search & browse Spotify genre/mood pages with sections |
| [Spotify Audiobooks Scraper](https://apify.com/apiharvest/spotify-audiobooks-search-and-scraper) | Search & scrape Spotify audiobooks with chapter listings |
| [Spotify Episodes Scraper](https://apify.com/apiharvest/spotify-episodes-search-and-scraper) | Search & scrape Spotify podcast episodes with recommendations |
| [Spotify Podcasts Scraper](https://apify.com/apiharvest/spotify-podcasts-search-and-scraper) | Search & scrape Spotify podcasts/shows with episode listings |
| [Spotify Users Scraper](https://apify.com/apiharvest/spotify-users-search-and-profile-scraper) | Search & scrape Spotify user profiles with playlists |
| [Spotify Search — All Types](https://apify.com/apiharvest/spotify-search-all-types) | Search all 9 Spotify content types in one actor |
| [Spotify Scraper — Get Full Details](https://apify.com/apiharvest/spotify-scraper-get-full-details) | Get full details for 8 Spotify content types from URIs |

***

### 🏷️ Keywords

spotify scraper, spotify playlist scraper, scrape spotify playlists, spotify data extractor, spotify playlist data, apify spotify, spotify api alternative, best spotify scraper

# Actor input Schema

## `keyword` (type: `array`):

One or more search terms to find playlists on Spotify. Each keyword runs as a separate search.

💡 Leave empty and fill Spotify URIs below to use Get Details mode instead.

## `spotifyUris` (type: `array`):

One or more Spotify playlist URIs or URLs to fetch full metadata.
Examples: spotify:playlist:ID · https://open.spotify.com/playlist/ID

⚠️ Only playlist URIs/URLs are accepted. Other types will be skipped.
💡 Leave empty and fill Search Keywords above to use Search mode instead.

## `proxyCountry` (type: `string`):

Residential proxy exit country. ⭐ US recommended — widest catalog.
If results are empty, switch to US.

## `playlists_search_offset` (type: `integer`):

Starting position for search pagination. 0 = first page.
📌 Only used in Search mode.

## `playlists_search_limit` (type: `integer`):

Maximum number of playlist results to return per keyword.

## `playlists_search_numberOfTopResults` (type: `integer`):

Number of top-ranked items highlighted in the response.

## `playlists_fetchDetails` (type: `boolean`):

������ Search mode only — when using Playlist URIs/URLs, full details are always fetched automatically.

✅ When ON — runs fetchPlaylist for every search result. You get: full paginated track listings, follower count, owner profile, playlist description, collaborative status, and all cover art variants.

❌ When OFF — you only get basic search data: playlist name, owner name, image, track count, and URI. You will NOT get the actual track list, follower count, or description.

⚠️ Slower — one extra API call per search result.

## `playlists_get_offset` (type: `integer`):

Starting position in the playlist's track list. 0 = first track.
📌 Active in Get Details mode (always) and in Search mode when Fetch Full Playlist Details is ON.

## `playlists_get_limit` (type: `integer`):

Maximum number of tracks to return from the playlist.

## Actor input object example

```json
{
  "keyword": [
    "Workout",
    "Chill"
  ],
  "spotifyUris": [
    "spotify:playlist:37i9dQZF1DXcBWIGoYBM5M",
    "https://open.spotify.com/playlist/51NIMAKN9Qpe1nzsXGfFH8"
  ],
  "proxyCountry": "US",
  "playlists_search_offset": 0,
  "playlists_search_limit": 30,
  "playlists_search_numberOfTopResults": 20,
  "playlists_fetchDetails": false,
  "playlists_get_offset": 0,
  "playlists_get_limit": 25
}
```

# 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 = {
    "keyword": [
        "Workout",
        "Chill"
    ],
    "spotifyUris": [
        "spotify:playlist:37i9dQZF1DXcBWIGoYBM5M",
        "https://open.spotify.com/playlist/51NIMAKN9Qpe1nzsXGfFH8"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apiharvest/spotify-playlists-search-and-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 = {
    "keyword": [
        "Workout",
        "Chill",
    ],
    "spotifyUris": [
        "spotify:playlist:37i9dQZF1DXcBWIGoYBM5M",
        "https://open.spotify.com/playlist/51NIMAKN9Qpe1nzsXGfFH8",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("apiharvest/spotify-playlists-search-and-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 '{
  "keyword": [
    "Workout",
    "Chill"
  ],
  "spotifyUris": [
    "spotify:playlist:37i9dQZF1DXcBWIGoYBM5M",
    "https://open.spotify.com/playlist/51NIMAKN9Qpe1nzsXGfFH8"
  ]
}' |
apify call apiharvest/spotify-playlists-search-and-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Playlists Search and Scraper 🎧",
        "description": "🎧 Scrape  playlists' full paginated track listings, owner profile, follower count, description, cover art & collaborative status. Enable Fetch Details to get every track in the playlist, not just search previews. Complete playlist data same as Spotify app ✨Spotify Playlists Search and Scraper 🎧",
        "version": "0.0",
        "x-build-id": "dImEzmTaOFLGblySt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apiharvest~spotify-playlists-search-and-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apiharvest-spotify-playlists-search-and-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/apiharvest~spotify-playlists-search-and-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apiharvest-spotify-playlists-search-and-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/apiharvest~spotify-playlists-search-and-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apiharvest-spotify-playlists-search-and-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": {
                    "keyword": {
                        "title": "🔍 Search Keyword(s)",
                        "type": "array",
                        "description": "One or more search terms to find playlists on Spotify. Each keyword runs as a separate search.\n\n💡 Leave empty and fill Spotify URIs below to use Get Details mode instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "spotifyUris": {
                        "title": "🔗 Spotify Playlist URIs / URLs",
                        "type": "array",
                        "description": "One or more Spotify playlist URIs or URLs to fetch full metadata.\nExamples: spotify:playlist:ID · https://open.spotify.com/playlist/ID\n\n⚠️ Only playlist URIs/URLs are accepted. Other types will be skipped.\n💡 Leave empty and fill Search Keywords above to use Search mode instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyCountry": {
                        "title": "🌐 Proxy Country",
                        "enum": [
                            "US",
                            "GB",
                            "AU",
                            "CA",
                            "DE",
                            "FR",
                            "NL",
                            "IT",
                            "ES",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "BE",
                            "AT",
                            "CH",
                            "IE",
                            "PL",
                            "PT",
                            "CZ",
                            "HU",
                            "RO",
                            "GR",
                            "BG",
                            "HR",
                            "SK",
                            "RS",
                            "JP",
                            "KR",
                            "SG",
                            "HK",
                            "TW",
                            "TH",
                            "MY",
                            "ID",
                            "PH",
                            "VN",
                            "IN",
                            "BR",
                            "MX",
                            "AR",
                            "CL",
                            "CO",
                            "PE",
                            "ZA",
                            "NG",
                            "KE",
                            "EG",
                            "SA",
                            "AE",
                            "TR",
                            "IL",
                            "UA",
                            "RU",
                            "BY"
                        ],
                        "type": "string",
                        "description": "Residential proxy exit country. ⭐ US recommended — widest catalog.\nIf results are empty, switch to US.",
                        "default": "US"
                    },
                    "playlists_search_offset": {
                        "title": "📄 Search Offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Starting position for search pagination. 0 = first page.\n📌 Only used in Search mode.",
                        "default": 0
                    },
                    "playlists_search_limit": {
                        "title": "📊 Search Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of playlist results to return per keyword.",
                        "default": 30
                    },
                    "playlists_search_numberOfTopResults": {
                        "title": "🏆 Top Results Count",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of top-ranked items highlighted in the response.",
                        "default": 20
                    },
                    "playlists_fetchDetails": {
                        "title": "🔄 Fetch Full Playlist Details",
                        "type": "boolean",
                        "description": "������ Search mode only — when using Playlist URIs/URLs, full details are always fetched automatically.\n\n✅ When ON — runs fetchPlaylist for every search result. You get: full paginated track listings, follower count, owner profile, playlist description, collaborative status, and all cover art variants.\n\n❌ When OFF — you only get basic search data: playlist name, owner name, image, track count, and URI. You will NOT get the actual track list, follower count, or description.\n\n⚠️ Slower — one extra API call per search result.",
                        "default": false
                    },
                    "playlists_get_offset": {
                        "title": "📄 Track List Offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Starting position in the playlist's track list. 0 = first track.\n📌 Active in Get Details mode (always) and in Search mode when Fetch Full Playlist Details is ON.",
                        "default": 0
                    },
                    "playlists_get_limit": {
                        "title": "📊 Track List Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of tracks to return from the playlist.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
