# Spotify Users Search and Profile Scraper 👤 (`apiharvest/spotify-users-search-and-profile-scraper`) Actor

👤 Scrape Spotify user profiles with public playlists, follower & following counts, profile images, display names & playlist metadata. Fetch full profile enrichment with all public playlist data. The most complete Spotify user data scraper available ✨Spotify Users Search and Profile Scraper 👤

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

## Pricing

$9.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Users Scraper — Search & Scrape Complete Spotify User Profiles | Best Spotify Scraper | Best Spotify Scraper

### What is the Spotify Users Scraper?

The **Spotify Users Scraper** is a specialized Apify actor that lets you search and scrape Spotify user profiles at scale. This Spotify users scraper combines fast API-based search with deep browser-based profile scraping to extract user data including display names, follower/following counts, public playlists, and recently played artists — directly from Spotify. No Spotify API key, no login credentials, no developer account required.

This Spotify users scraper is unique among the Spotify scrapers because it uses a **hybrid architecture**: fast API search for finding Spotify users, and a headless browser (crawl4ai + Playwright) for scraping detailed Spotify user profile pages that require JavaScript rendering.

---

### IMPORTANT: Speed Warning

**Profile detail scraping is SLOW.** The Spotify users scraper uses a headless Chromium browser to render full Spotify user profile pages. Each Spotify user profile takes approximately **5-10 minutes** to fully scrape.

- **Search mode** (without Fetch Details) is **fast** — API-based, returns results in seconds
- **Detail scraping** (Fetch Details ON or Get Details mode) is **slow** — 5-10 minutes per Spotify user profile

Plan your runs accordingly. For 100 Spotify user profiles with full details, expect a run time of 8-16 hours.

---

### How Does This Spotify Users Scraper Work?

This Spotify users scraper operates in **two modes**:

#### Mode 1: Search Spotify Users by Keyword (Fast)

Enter keywords and the Spotify users scraper searches Spotify's user directory via the API. Returns basic Spotify user profile data: username, display name, avatar image, and URI. This is fast — similar speed to other Spotify scrapers.

**Example keywords:** `"music lover"`, `"DJ"`, `"hip hop fan"`, `"playlist curator"`, `"vinyl collector"`

#### Mode 2: Scrape Full Spotify User Profiles by URI or URL (Slow)

Paste Spotify user URIs or URLs and the Spotify users scraper launches a headless browser to scrape each profile page. Returns rich data including follower/following counts, all public playlists with creation dates, and recently played artists.

The Spotify users scraper accepts URI format (`spotify:user:USERNAME`) and URL format (`https://open.spotify.com/user/USERNAME`).

#### Auto-Detection

The Spotify users scraper automatically detects the mode:

- **Fill Search Keywords** → Fast Spotify users search (API-based)
- **Fill Spotify User URIs / URLs** → Slow detailed Spotify user profile scraping (browser-based)
- **Fill both** → Search first, then scrape profiles

---

### Input Configuration

| Field | Mode | Description | Default |
|-------|------|-------------|---------|
| **Search Keywords** | Search | Keywords to search Spotify users. | — |
| **Spotify User URIs / URLs** | Details | `spotify:user:ID` or `https://open.spotify.com/user/ID` | — |
| **Proxy Country** | Both | Residential proxy country. US recommended. | US |
| **Search Offset** | Search | Starting position for search pagination. | 0 |
| **Search Limit** | Search | Maximum Spotify users per keyword. | 30 |
| **Top Results Count** | Search | Number of top-ranked Spotify users. | 20 |
| **Fetch Full Profile Details** | Search | **SLOW (5-10 min/profile):** Launch browser for each Spotify user search result. | OFF |

#### Understanding Filters & Toggles

| Toggle / Filter | Default | What Happens When ON | What You Miss When OFF |
|----------------|---------|---------------------|----------------------|
| **Fetch Full Profile Details** | OFF | Scrapes each user's full profile using a headless browser. You get: public playlists with cover images, follower/following counts, bio, profile image, and recently played artists. **⚠️ VERY SLOW: 5-10 minutes per profile!** | You only get basic search data — username, display name, image, URI, and follower count. No playlists, no bio, no detailed profile data. |
| **Include Playlists** | ON | Scrapes all public playlists with cover images and estimated creation dates. | Playlists will not be scraped — you only get profile info. |
| **Include Recently Played Artists** | ON | Scrapes recently played artists with images. Shows the user's listening activity. | Recently played artists will not be scraped. |
| **Search Limit** | 10 | Controls how many user results you get per keyword. | — |
| **Search Offset** | 0 | Skip results for pagination. | — |

> **⚠️ Important:** Include Playlists and Include Recently Played Artists only work when Fetch Full Profile Details is ON or when using Get Details mode (URIs/URLs). Only enable Fetch Full Profile Details for small batches due to the 5-10 minute processing time per profile.

---

### Output Data Format

#### Search Result Example (Fast — API-based)

```json
{
    "query": "music lover",
    "uri": "spotify:user:abc123",
    "username": "musiclover42",
    "displayName": "Music Lover",
    "avatar": {"sources": [{"url": "https://i.scdn.co/image/..."}]}
}
````

#### Full Profile Example (Slow — Browser-based)

```json
{
    "source_url": "https://open.spotify.com/user/abc123",
    "user_id": "abc123",
    "display_name": "Music Lover",
    "profile_image": "https://i.scdn.co/image/...",
    "followers": "1,234 Followers",
    "followers_count": 1234,
    "following": "42 Following",
    "following_count": 42,
    "total_public_playlists_count": 15,
    "playlists": [
        {
            "title": "My Favorite Songs",
            "url": "https://open.spotify.com/playlist/...",
            "image": "https://mosaic.scdn.co/...",
            "created_at_proxy": "Jan 2023"
        },
        {
            "title": "Workout Mix",
            "url": "https://open.spotify.com/playlist/...",
            "image": "https://mosaic.scdn.co/...",
            "created_at_proxy": "Mar 2024"
        }
    ],
    "recently_played_artists": [
        {
            "name": "Drake",
            "url": "https://open.spotify.com/artist/...",
            "image": "https://i.scdn.co/image/..."
        },
        {
            "name": "Taylor Swift",
            "url": "https://open.spotify.com/artist/...",
            "image": "https://i.scdn.co/image/..."
        }
    ]
}
```

The Spotify users scraper extracts data that is not available through any official API: follower/following counts, public playlists with estimated creation dates, and recently played artists.

***

### Step-by-Step Tutorial

#### How to Search Spotify Users (Fast)

1. Go to the **Spotify Users Scraper** actor page
2. Enter keywords like `"DJ"`, `"curator"`, `"music blog"`
3. Set **Proxy Country** to US
4. Keep **Fetch Full Profile Details** OFF for fast results
5. Click **Start** — results return in seconds

#### How to Scrape Full Spotify User Profiles (Slow)

1. Collect Spotify user URIs or profile URLs
2. Paste into the **Spotify User URIs / URLs** field
3. Set **Proxy Country** to US
4. Click **Start** — expect 5-10 minutes per Spotify user profile
5. Monitor progress in the actor log

#### Important Tips for Profile Scraping

- **Start small** — Test with 2-3 Spotify user URIs first to verify output
- **Set adequate timeout** — Spotify user profile scraping is slow; ensure your actor timeout accommodates the number of profiles
- **Budget time** — 10 profiles ≈ 1-2 hours, 100 profiles ≈ 8-16 hours
- **Proxy matters** — US proxy works best for the Spotify users scraper

***

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

#### Influencer & Curator Research

Find Spotify playlist curators by searching user profiles. The Spotify users scraper reveals follower counts, playlist portfolios, and listening habits.

#### Music Marketing

Identify target audiences by scraping Spotify user profiles and analyzing their playlists and recently played artists. Use the Spotify users scraper for audience segmentation.

#### Social Analysis

Study Spotify user behavior patterns — what playlists they create, which artists they listen to, and how their taste evolves over time.

#### Playlist Pitching

Find high-follower Spotify users who curate genre-specific playlists. The Spotify users scraper extracts public playlists with creation dates — ideal for identifying active curators.

#### Competitive Research

Analyze how fans engage with music on Spotify by scraping user profiles in specific niches.

***

### 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 — public playlists, follower/following counts, profile images, display names, and playlist metadata | 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 user profile actor on Apify gives you this level of complete, production-ready data.

### Frequently Asked Questions

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

**Q: Why is profile scraping so slow?**
A: Spotify user profiles are JavaScript-rendered pages. The Spotify users scraper must launch a full Chromium browser, wait for the page to render, and extract data from the DOM. This takes 5-10 minutes per Spotify user profile.

**Q: Can I speed up the Spotify users scraper?**
A: Search mode (without Fetch Details) is fast. Profile scraping speed is limited by browser rendering — this cannot be parallelized further within a single actor run.

**Q: What data is available from search vs. full profile?**
A: Search returns: username, display name, avatar. Full profile additionally returns: follower/following counts, all public playlists with images and creation dates, recently played artists.

**Q: Is there a limit on Spotify users I can scrape?**
A: No hard limit, but budget your time. 100 Spotify user profiles with details = 8-16 hours.

**Q: Why is there no detail surcharge?**
A: The higher compute cost of browser scraping is absorbed. The Spotify users scraper charges a flat $0.004 per result regardless of mode.

***

### Related Spotify Scrapers by apiharvest

| Actor | Description |
|-------|-------------|
| [Spotify Tracks Scraper](https://apify.com/apiharvest/spotify-tracks-search-and-scraper) | Search & scrape Spotify track metadata |
| [Spotify Albums Scraper](https://apify.com/apiharvest/spotify-albums-search-and-scraper) | Search & scrape Spotify album metadata |
| [Spotify Artists Scraper](https://apify.com/apiharvest/spotify-artists-search-and-scraper) | Search & scrape Spotify artist profiles |
| [Spotify Playlists Scraper](https://apify.com/apiharvest/spotify-playlists-search-and-scraper) | Search & scrape Spotify playlists |
| [Spotify Genres Scraper](https://apify.com/apiharvest/spotify-genres-search-and-scraper) | Browse Spotify genre/mood pages |
| [Spotify Audiobooks Scraper](https://apify.com/apiharvest/spotify-audiobooks-search-and-scraper) | Search & scrape Spotify audiobooks |
| [Spotify Episodes Scraper](https://apify.com/apiharvest/spotify-episodes-search-and-scraper) | Search & scrape Spotify podcast episodes |
| [Spotify Podcasts Scraper](https://apify.com/apiharvest/spotify-podcasts-search-and-scraper) | Search & scrape Spotify podcasts/shows |
| [Spotify Search — All Types](https://apify.com/apiharvest/spotify-search-all-types) | Search all 9 Spotify content types |
| [Spotify Scraper — Get Full Details](https://apify.com/apiharvest/spotify-scraper-get-full-details) | Get full details for 8 Spotify content types |

***

### 🏷️ Keywords

spotify scraper, spotify user scraper, scrape spotify profiles, spotify profile scraper, spotify data extractor, apify spotify, spotify api alternative, best spotify scraper

# Actor input Schema

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

One or more search terms to find user profiles on Spotify.

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

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

One or more Spotify user URIs or URLs to scrape full profile data.
Examples: spotify:user:ID · https://open.spotify.com/user/ID

⚠️ SLOW: Each profile takes 5-10 minutes (headless browser scraping).
💡 Leave empty and fill Search Keywords above to use Search mode instead.

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

Select a proxy country for scraping. ⭐ US recommended for best results.

## `users_search_offset` (type: `integer`):

Starting position for search pagination.

## `users_search_limit` (type: `integer`):

Maximum number of results per keyword.

## `users_search_numberOfTopResults` (type: `integer`):

Number of top-ranked items.

## `users_fetchDetails` (type: `boolean`):

Search mode only — Get Details mode always fetches full details.

✅ When ON — scrapes each user's full profile using a headless browser. You get: public playlists with cover images, follower/following counts, bio, profile image, and recently played artists.

❌ When OFF — you only get basic search data: username, display name, image, URI, and follower count. You will NOT get public playlists, bio, or detailed profile data.

⚠️⚠️ VERY SLOW: 5-10 minutes per profile! Only enable for small batches.

## `includePlaylists` (type: `boolean`):

✅ When ON — scrapes all public playlists with cover images and estimated creation dates. Included by default.

❌ When OFF — playlists will not be scraped. You will only get profile info without any playlist data. Turn ON to include user's public playlists.

Only applies when Fetch Full Profile Details is ON or in Get Details mode.

## `includeRecentlyPlayedArtists` (type: `boolean`):

✅ When ON — scrapes recently played artists with images. Shows the user's listening activity. Included by default.

❌ When OFF — recently played artists will not be scraped. Turn ON to see what artists the user listens to.

Only applies when Fetch Full Profile Details is ON or in Get Details mode.

## Actor input object example

```json
{
  "keyword": [
    "Rock",
    "sun"
  ],
  "proxyCountry": "US",
  "users_search_offset": 0,
  "users_search_limit": 30,
  "users_search_numberOfTopResults": 20,
  "users_fetchDetails": false,
  "includePlaylists": true,
  "includeRecentlyPlayedArtists": true
}
```

# 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": [
        "Rock",
        "sun"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apiharvest/spotify-users-search-and-profile-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": [
        "Rock",
        "sun",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("apiharvest/spotify-users-search-and-profile-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": [
    "Rock",
    "sun"
  ]
}' |
apify call apiharvest/spotify-users-search-and-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Users Search and Profile Scraper 👤",
        "description": "👤 Scrape Spotify user profiles with public playlists, follower & following counts, profile images, display names & playlist metadata. Fetch full profile enrichment with all public playlist data. The most complete Spotify user data scraper available ✨Spotify Users Search and Profile Scraper 👤",
        "version": "0.0",
        "x-build-id": "wCd5NgKmQWqpolziB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apiharvest~spotify-users-search-and-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apiharvest-spotify-users-search-and-profile-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-users-search-and-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apiharvest-spotify-users-search-and-profile-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-users-search-and-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apiharvest-spotify-users-search-and-profile-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 user profiles on Spotify.\n\n💡 Leave empty and fill Spotify URIs below to use Get Details mode instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "spotifyUris": {
                        "title": "🔗 Spotify User URIs / URLs",
                        "type": "array",
                        "description": "One or more Spotify user URIs or URLs to scrape full profile data.\nExamples: spotify:user:ID · https://open.spotify.com/user/ID\n\n⚠️ SLOW: Each profile takes 5-10 minutes (headless browser scraping).\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": "Select a proxy country for scraping. ⭐ US recommended for best results.",
                        "default": "US"
                    },
                    "users_search_offset": {
                        "title": "📄 Search Offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Starting position for search pagination.",
                        "default": 0
                    },
                    "users_search_limit": {
                        "title": "📊 Search Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of results per keyword.",
                        "default": 30
                    },
                    "users_search_numberOfTopResults": {
                        "title": "🏆 Top Results Count",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of top-ranked items.",
                        "default": 20
                    },
                    "users_fetchDetails": {
                        "title": "🔄 Fetch Full Profile Details",
                        "type": "boolean",
                        "description": "Search mode only — Get Details mode always fetches full details.\n\n✅ When ON — scrapes each user's full profile using a headless browser. You get: public playlists with cover images, follower/following counts, bio, profile image, and recently played artists.\n\n❌ When OFF — you only get basic search data: username, display name, image, URI, and follower count. You will NOT get public playlists, bio, or detailed profile data.\n\n⚠️⚠️ VERY SLOW: 5-10 minutes per profile! Only enable for small batches.",
                        "default": false
                    },
                    "includePlaylists": {
                        "title": "📋 Include Public Playlists",
                        "type": "boolean",
                        "description": "✅ When ON — scrapes all public playlists with cover images and estimated creation dates. Included by default.\n\n❌ When OFF — playlists will not be scraped. You will only get profile info without any playlist data. Turn ON to include user's public playlists.\n\nOnly applies when Fetch Full Profile Details is ON or in Get Details mode.",
                        "default": true
                    },
                    "includeRecentlyPlayedArtists": {
                        "title": "🎵 Include Recently Played Artists",
                        "type": "boolean",
                        "description": "✅ When ON — scrapes recently played artists with images. Shows the user's listening activity. Included by default.\n\n❌ When OFF — recently played artists will not be scraped. Turn ON to see what artists the user listens to.\n\nOnly applies when Fetch Full Profile Details is ON or in Get Details mode.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
