# Spotify Albums Search and Scraper 💿 (`apiharvest/spotify-albums-search-and-scraper`) Actor

💿 Scrape Spotify albums with complete track listings, label name, copyright info, cover art in all sizes, release date precision, disc metadata & artist credits. Turn on Fetch Details for paginated tracklists and full album enrichment. Returns the exact same data Spotify uses internally.

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

## Pricing

$10.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 Albums Scraper — Search & Scrape Complete Spotify Album Data | Best Spotify Scraper

### What is the Spotify Albums Scraper?

The **Spotify Albums Scraper** is a production-ready Apify actor designed to search and scrape Spotify albums at scale. This Spotify albums scraper extracts complete album metadata including full track listings, release dates, labels, cover art, and more — directly from Spotify. No Spotify API key, no login credentials, no developer account needed.

Unlike the official Spotify Web API which imposes strict rate limits and requires OAuth authentication, this Spotify albums scraper uses Spotify's internal API to pull rich, structured album data. The Spotify albums scraper automatically handles token rotation, proxy management, and retry logic for reliable large-scale scraping.

---

### How Does This Spotify Albums Scraper Work?

This Spotify albums scraper operates in **two modes** that are auto-detected from your input:

#### Mode 1: Search Spotify Albums by Keyword

Enter one or more keywords and the Spotify albums scraper searches Spotify's catalog for matching albums. You can search by album title, artist name, genre, or any combination. The Spotify albums scraper returns structured results for every matching Spotify album.

**Example keywords:** `"The Dark Side of the Moon"`, `"Taylor Swift"`, `"jazz classics"`, `"2024 hip hop"`, `"Adele 30"`

#### Mode 2: Scrape Specific Spotify Albums by URI or URL

Already have Spotify album links? Paste them directly. The Spotify albums scraper accepts both URI format (`spotify:album:2cWBwpqMsDJC1ZUwz813lj`) and URL format (`https://open.spotify.com/album/2cWBwpqMsDJC1ZUwz813lj`). Each Spotify album URI is resolved to its full metadata including the complete track listing.

#### Auto-Detection

You don't need to choose a mode manually. The Spotify albums scraper automatically detects what to do:

- **Fill Search Keywords** → Spotify albums search mode activates
- **Fill Spotify Album URIs / URLs** → Spotify album details mode activates
- **Fill both** → The Spotify albums scraper runs search first, then fetches details for the URIs

#### Detail Enrichment (Search Mode)

When searching, the Spotify albums scraper returns basic search results by default. Enable **Fetch Full Album Details** to automatically enrich each search result with complete Spotify album metadata including track listings — the Spotify albums scraper will call the detail API for every result.

---

### Input Configuration

| Field | Mode | Description | Default |
|-------|------|-------------|---------|
| **Search Keywords** | Search | One or more keywords to search Spotify albums. Each keyword runs as a separate search query. | — |
| **Spotify Album URIs / URLs** | Details | One or more `spotify:album:ID` URIs or `https://open.spotify.com/album/ID` URLs | — |
| **Proxy Country** | Both | Residential proxy country (50+ available). US recommended for best Spotify albums scraper results. | US |
| **Search Offset** | Search | Starting position for search pagination. Use to skip already-scraped Spotify albums. | 0 |
| **Search Limit** | Search | Maximum number of Spotify albums to return per keyword. | 30 |
| **Top Results Count** | Search | Number of top-ranked Spotify albums in the results. | 20 |
| **Fetch Full Album Details** | Search | When ON, the Spotify albums scraper enriches each search result with complete metadata. | OFF |
| **Track List Offset** | Details | Starting position for the Spotify album track list. Use to paginate through long albums. | 0 |
| **Track List Limit** | Details | Maximum number of tracks to return from each Spotify album. | 50 |

#### Understanding Filters & Toggles

| Toggle / Filter | Default | What Happens When ON | What You Miss When OFF |
|----------------|---------|---------------------|----------------------|
| **Fetch Full Album Details** | OFF | Each search result is enriched with complete metadata: full track listings, label name, copyright info, all cover art sizes, release date with day precision, disc metadata, and full artist credits. Costs extra Per/result. | You only get basic search data — album name, artist, release year, cover art, and URI. No track list, no label, no copyright info. |
| **Track List Offset** | 0 | Start position in the album's track list. Use for paginating long albums. | — |
| **Track List Limit** | 25 | Max tracks to return from each album. Increase for albums with 25+ tracks. | — |
| **Search Limit** | 10 | Controls how many album results you get per keyword. | — |
| **Search Offset** | 0 | Skip results for pagination. | — |

> **💡 Tip:** When using Album URIs/URLs (Get Details mode), full details are **always** fetched automatically — the Fetch Full Album Details toggle only applies to Search mode.

#### URL Validation

The Spotify albums scraper validates every URI you provide. If you accidentally paste a track, artist, or playlist URI, the Spotify albums scraper will skip it and log a helpful message telling you exactly which actor to use instead.

---

### Output Data Format

Every Spotify album scraped by this Spotify albums scraper is pushed as a structured JSON object to the Apify dataset. You can export in JSON, CSV, XML, Excel, or connect via the Apify API.

#### Search Result Example

```json
{
    "query": "The Eminem Show",
    "uri": "spotify:album:2cWBwpqMsDJC1ZUwz813lj",
    "name": "The Eminem Show",
    "artists": [
        {"name": "Eminem", "uri": "spotify:artist:7dGJo4pcD2V6oG08qCgod6"}
    ],
    "date": {"year": 2002},
    "coverArt": {"sources": [{"url": "https://i.scdn.co/image/..."}]}
}
````

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

```json
{
    "uri": "spotify:album:2cWBwpqMsDJC1ZUwz813lj",
    "name": "The Eminem Show",
    "artists": [
        {"name": "Eminem", "uri": "spotify:artist:7dGJo4pcD2V6oG08qCgod6"}
    ],
    "date": {"year": 2002, "month": 5, "day": 26},
    "label": "Aftermath",
    "copyright": {"items": [{"text": "(C) 2002 Aftermath Records"}]},
    "coverArt": {"sources": [{"url": "https://i.scdn.co/image/...", "width": 640, "height": 640}]},
    "tracks": {
        "totalCount": 20,
        "items": [
            {"track": {"name": "Curtains Up (Skit)", "uri": "spotify:track:...", "duration": {"totalMilliseconds": 30000}, "playcount": "123456789"}},
            {"track": {"name": "White America", "uri": "spotify:track:...", "duration": {"totalMilliseconds": 326000}, "playcount": "456789012"}}
        ]
    },
    "moreAlbumsByArtist": {"items": [{"name": "Recovery", "uri": "spotify:album:..."}]}
}
```

***

### Step-by-Step Tutorial

#### How to Search Spotify Albums

1. Go to the **Spotify Albums Scraper** actor page on Apify
2. Enter your keywords in the **Search Keywords** field — e.g., `"Beatles"`, `"2024 pop albums"`, `"classical symphonies"`
3. Set **Proxy Country** to US (recommended)
4. Adjust **Search Limit** if you want more or fewer Spotify albums per keyword
5. (Optional) Turn on **Fetch Full Album Details** to get complete metadata with track listings
6. Set your **spending limit** and click **Start**
7. Download results from the Dataset tab in JSON, CSV, or Excel format

#### How to Scrape Specific Spotify Albums

1. Collect Spotify album URIs or URLs (right-click an album in Spotify → Share → Copy Spotify URI)
2. Paste them into the **Spotify Album URIs / URLs** field
3. Set **Track List Limit** to control how many tracks per Spotify album (default 50)
4. Click **Start**
5. Each Spotify album URI is resolved to full metadata with track listings

***

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

#### Discography Research

Scrape entire artist discographies by searching for artist names and enabling full album details. The Spotify albums scraper returns every Spotify album with complete track listings and release metadata.

#### Label Monitoring

Music labels can use the Spotify albums scraper to monitor new releases, track catalog performance, and analyze release patterns across artists and genres.

#### Music Catalog Building

Build comprehensive music databases by scraping Spotify album metadata at scale. The Spotify albums scraper outputs structured data ready for database import.

#### Academic Research

Researchers studying album structure, release strategies, or music trends can use this Spotify albums scraper for large-scale data collection.

#### Data Journalism

Journalists can scrape Spotify albums to support stories about the music industry with real data on releases, labels, and album performance.

#### App Development

Developers building music apps can use the Spotify albums scraper to populate databases with rich Spotify album metadata and cover art URLs.

***

### 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 — complete track listings, label info, copyright data, cover art variants, release precision, and disc 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 album actor on Apify gives you this level of complete, production-ready data.

### Frequently Asked Questions

**Q: Does this Spotify albums scraper require a Spotify account or API key?**
A: No. This Spotify albums scraper works completely without authentication. No Spotify developer account needed.

**Q: Can I get the full track list from a Spotify album?**
A: Yes. Use the Track List Offset/Limit controls in Get Details mode, or enable Fetch Details in Search mode. The Spotify albums scraper returns complete track listings.

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

**Q: What if a Spotify album has more than 50 tracks?**
A: Increase the **Track List Limit** input field. The Spotify albums scraper supports pagination for large albums like compilations or box sets.

**Q: Can I run this Spotify albums scraper on a schedule?**
A: Yes. Use Apify's scheduling feature to run the Spotify albums scraper at any interval for monitoring new releases.

**Q: What output formats does the Spotify albums scraper support?**
A: JSON, CSV, XML, Excel, and direct API access via the Apify Dataset API.

**Q: How fast is this Spotify albums scraper?**
A: Search mode returns results in seconds. Get Details mode processes each Spotify album sequentially, typically a few seconds per album.

**Q: What's the difference between this and the Spotify Scraper (combo actor)?**
A: This Spotify albums scraper is specialized for Spotify albums with album-specific features (track list pagination). The Spotify Scraper combo actor handles 8 types but in a single interface.

***

### Integrations

Connect the Spotify albums scraper output to your favorite tools:

- **Google Sheets** — Auto-export Spotify album data to spreadsheets
- **Slack / Discord** — Get notifications when the Spotify albums scraper finishes
- **Webhooks** — Trigger custom workflows with Spotify album data
- **REST API** — Access Spotify albums scraper results programmatically

***

### 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 Artists Scraper](https://apify.com/apiharvest/spotify-artists-search-and-scraper) | Search & scrape Spotify artist profiles, discography, related artists |
| [Spotify Playlists Scraper](https://apify.com/apiharvest/spotify-playlists-search-and-scraper) | Search & scrape Spotify playlists with full track listings |
| [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 album scraper, scrape spotify albums, spotify data extractor, spotify album data, apify spotify, spotify api alternative, best spotify scraper

# Actor input Schema

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

One or more search terms to find albums 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 album URIs or URLs to fetch full metadata.
Examples: spotify:album:ID · https://open.spotify.com/album/ID

⚠️ Only album URIs/URLs are accepted. Other types (tracks, artists, etc.) 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.

## `albums_search_offset` (type: `integer`):

Starting position for search pagination. 0 = first page.
📌 Only used in Search mode (when keywords are provided).

## `albums_search_limit` (type: `integer`):

Maximum number of album results to return per keyword.

## `albums_search_numberOfTopResults` (type: `integer`):

Number of top-ranked items highlighted in the response.

## `albums_fetchDetails` (type: `boolean`):

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

✅ When ON — runs getAlbum for every search result. You get: complete track listings (paginated), label name, copyright info, all cover art sizes, release date with day precision, disc metadata, and full artist credits.

❌ When OFF — you only get basic search data: album name, artist name, release year, cover art, and URI. You will NOT get the track list, label, copyright, or any detailed metadata.

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

## `albums_get_offset` (type: `integer`):

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

## `albums_get_limit` (type: `integer`):

Maximum number of tracks to return from the album.

## Actor input object example

```json
{
  "keyword": [
    "Rock",
    "Sun"
  ],
  "spotifyUris": [
    "spotify:album:1DFixLWuPkv3KT3TnV35m3",
    "https://open.spotify.com/album/6dVIqQ8qmQ5GBnJ9shOYGE"
  ],
  "proxyCountry": "US",
  "albums_search_offset": 0,
  "albums_search_limit": 10,
  "albums_search_numberOfTopResults": 10,
  "albums_fetchDetails": false,
  "albums_get_offset": 0,
  "albums_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": [
        "Rock",
        "Sun"
    ],
    "spotifyUris": [
        "spotify:album:1DFixLWuPkv3KT3TnV35m3",
        "https://open.spotify.com/album/6dVIqQ8qmQ5GBnJ9shOYGE"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apiharvest/spotify-albums-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": [
        "Rock",
        "Sun",
    ],
    "spotifyUris": [
        "spotify:album:1DFixLWuPkv3KT3TnV35m3",
        "https://open.spotify.com/album/6dVIqQ8qmQ5GBnJ9shOYGE",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("apiharvest/spotify-albums-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": [
    "Rock",
    "Sun"
  ],
  "spotifyUris": [
    "spotify:album:1DFixLWuPkv3KT3TnV35m3",
    "https://open.spotify.com/album/6dVIqQ8qmQ5GBnJ9shOYGE"
  ]
}' |
apify call apiharvest/spotify-albums-search-and-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Albums Search and Scraper 💿",
        "description": "💿 Scrape Spotify albums with complete track listings, label name, copyright info, cover art in all sizes, release date precision, disc metadata & artist credits. Turn on Fetch Details for paginated tracklists and full album enrichment. Returns the exact same data Spotify uses internally.",
        "version": "0.0",
        "x-build-id": "fNB145xCJ2Q1BRcEK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apiharvest~spotify-albums-search-and-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apiharvest-spotify-albums-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-albums-search-and-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apiharvest-spotify-albums-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-albums-search-and-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apiharvest-spotify-albums-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 albums 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 Album URIs / URLs",
                        "type": "array",
                        "description": "One or more Spotify album URIs or URLs to fetch full metadata.\nExamples: spotify:album:ID · https://open.spotify.com/album/ID\n\n⚠️ Only album URIs/URLs are accepted. Other types (tracks, artists, etc.) 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"
                    },
                    "albums_search_offset": {
                        "title": "📄 Search Offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Starting position for search pagination. 0 = first page.\n📌 Only used in Search mode (when keywords are provided).",
                        "default": 0
                    },
                    "albums_search_limit": {
                        "title": "📊 Search Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of album results to return per keyword.",
                        "default": 10
                    },
                    "albums_search_numberOfTopResults": {
                        "title": "🏆 Top Results Count",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of top-ranked items highlighted in the response.",
                        "default": 10
                    },
                    "albums_fetchDetails": {
                        "title": "🔄 Fetch Full Album Details",
                        "type": "boolean",
                        "description": "📌 Search mode only — when using Album URIs/URLs, full details are always fetched automatically.\n\n✅ When ON — runs getAlbum for every search result. You get: complete track listings (paginated), label name, copyright info, all cover art sizes, release date with day precision, disc metadata, and full artist credits.\n\n❌ When OFF — you only get basic search data: album name, artist name, release year, cover art, and URI. You will NOT get the track list, label, copyright, or any detailed metadata.\n\n⚠️ Slower — one extra API call per search result.",
                        "default": false
                    },
                    "albums_get_offset": {
                        "title": "📄 Track List Offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Starting position in the album's track list. 0 = first track.\n📌 Active in Get Details mode (always) and in Search mode when Fetch Full Album Details is ON.",
                        "default": 0
                    },
                    "albums_get_limit": {
                        "title": "📊 Track List Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of tracks to return from the album.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
