# NCS Music Scraper (`futuristforever/ncs-music-scraper`) Actor

Scrape tracks, artists, genres, moods, search results, and track metadata from NoCopyrightSounds (NCS).

- **URL**: https://apify.com/futuristforever/ncs-music-scraper.md
- **Developed by:** [Dhruv Kumar](https://apify.com/futuristforever) (community)
- **Categories:** Agents, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## NCS Music Scraper

Scrape tracks, artists, genres, moods, and full track metadata from [NoCopyrightSounds (ncs.io)](https://ncs.io) — the world's largest royalty-free music library for content creators. Nine crawl modes let you pull anything from a single track's download URL to a full catalogue export, all via a simple JSON input. Run on [Apify](https://apify.com) for scheduled exports, REST API access, and automatic proxy rotation without any infrastructure setup.

### What does NCS Music Scraper do?

NCS Music Scraper crawls the public NCS website and extracts structured data about tracks and artists. Depending on the mode you choose, it can:

- **Page through the full music library** and collect track titles, artists, genres, preview URLs, and cover art.
- **Search by keyword, genre, and mood** to find tracks matching specific criteria.
- **Visit individual track pages** to capture download URLs and full descriptions.
- **Crawl all artist profiles** to gather bios, genre tags, and cover images.
- **Extract an artist's complete discography** from their profile page.
- **List all genre and mood IDs** so you can use them as filters in subsequent searches.

### Why use NCS Music Scraper?

- **Content discovery** — find royalty-free tracks by genre or mood for YouTube videos, games, or podcasts without manual browsing.
- **Catalogue monitoring** — schedule daily or weekly runs to detect new NCS releases automatically.
- **Artist research** — pull bios, genres, and full discographies in a single crawl.
- **Data pipelines** — feed track metadata into a CMS, playlist generator, or recommendation engine via the Apify API or dataset exports.
- **Bulk download preparation** — collect download URLs across hundreds of tracks in one run for offline archiving.

### How to use NCS Music Scraper

1. Open the Actor on [Apify Console](https://console.apify.com) and click **Try for free**.
2. Select a **Mode** from the dropdown (see the Input section below for full descriptions).
3. Set any optional filters — genre, mood, version, page limits.
4. Click **Start** and wait for the run to finish (seconds to minutes depending on scope).
5. Open the **Output** tab to preview results, or download the dataset as **JSON, CSV, Excel, or XML**.

### Input

All inputs are optional except `mode`. Fields that don't apply to the selected mode are ignored.

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `library` | Crawl target — see modes table below |
| `max_pages` | integer | `5` | Library pages to crawl (`library`, `full`) |
| `max_search_pages` | integer | `1` | Search result pages to fetch (`search`) |
| `query` | string | `""` | Keyword, track, or artist name (`search`) |
| `artist` | string | `""` | Artist name (`artist_tracks`) |
| `track_url` | string | `""` | Direct NCS track URL (`track`) |
| `artist_url` | string | `""` | Direct NCS artist URL (`artist`) |
| `genre_name` | string | `""` | Genre filter by name, e.g. `"drum & bass"` (`search`) |
| `genre` | string | `""` | Genre filter by numeric ID — overridden by `genre_name` (`search`) |
| `mood_name` | string | `""` | Mood filter by name, e.g. `"energetic"` (`search`) |
| `mood` | string | `""` | Mood filter by numeric ID — overridden by `mood_name` (`search`) |
| `version` | string | `regular` | Track version: `regular`, `instrumental`, `regular-instrumental` (`search`) |
| `crawl_track_pages` | boolean | `false` | Visit individual track pages for download URLs (`library`, `full`) |
| `crawl_artist_pages` | boolean | `true` | Visit artist profiles found during library crawl (`library`, `full`) |
| `crawl_artist_tracks` | boolean | `false` | Extract track listings from each artist's profile page |
| `scrape_popular` | boolean | `true` | Collect the 5 featured Popular Releases shown at the top of the library (page 1 only) (`library`, `full`) |
| `scrape_recent` | boolean | `true` | Collect tracks from the paginated Recent Releases table (`library`, `full`) |

#### Modes

| Mode | Description |
|---|---|
| `library` | Page through the NCS music catalogue. Produces `popular_track` records for the 5 featured releases (scraped once from page 1) and `track` records for the paginated recent releases — both enabled by default. Optionally produces `track_detail` and `artist` records if the crawl flags are enabled. |
| `artists` | Crawl all artist profile pages. Produces `artist` records. |
| `full` | Library + artists in one run. |
| `search` | Search NCS by keyword, genre, and/or mood. Produces `search_result` records. |
| `artist_tracks` | All tracks for a specific artist via the NCS search. Produces `artist_track` records. |
| `track` | Scrape a single track from a direct URL. Produces one `track_detail` record including the download URL. |
| `artist` | Scrape a single artist profile from a direct URL. Produces one `artist` record (and optionally `artist_track` records if `crawl_artist_tracks` is enabled). |
| `genres` | List all NCS genre IDs and names. Produces `genre` records. |
| `moods` | List all NCS mood IDs and names. Produces `mood` records. |

#### Example input — search

```json
{
  "mode": "search",
  "query": "Alan Walker",
  "genre_name": "house",
  "mood_name": "energetic",
  "version": "regular",
  "max_search_pages": 3
}
````

#### Example input — full library with download URLs

```json
{
  "mode": "full",
  "max_pages": 10,
  "crawl_track_pages": true,
  "crawl_artist_tracks": true
}
```

### Output

Results are saved to the Apify dataset. Download them from the Output tab as **JSON, CSV, Excel, or XML**.

Every record has a `type` field indicating its kind. The possible types are:
`track`, `popular_track`, `track_detail`, `artist`, `artist_track`, `search_result`, `genre`, `mood`.

#### Example — search\_result

```json
{
  "type": "search_result",
  "track_id": "5c18afc2-c39c-4844-a08b-4c14e91d19fd",
  "title": "Dreamer (Rival Remix)",
  "artists": "Rival, Alan Walker",
  "genres": "Trap",
  "versions": "Regular",
  "preview_url": "https://ncsmusic.s3.eu-west-1.amazonaws.com/tracks/000/001/408/dreamer-rival-remix-1683417648-tlG33Woje8.mp3",
  "cover_url": "https://ncsmusic.s3.eu-west-1.amazonaws.com/tracks/000/001/408/100x100/dreamer-rival-remix-1683417646-Zn4BnPGZqR.jpg",
  "release_date": "7 May 2023",
  "moods": [
    "energetic",
    "Euphoric",
    "Glamorous",
    "Happy",
    "Epic",
    "Weird"
  ],
  "track_url": "https://ncs.io/rival_dreamer"
}
```

#### Example — popular\_track

```json
{
  "type": "popular_track",
  "track_id": "dd8b733e-d94a-4a9e-8349-f2674acb21ed",
  "title": "FAVELA",
  "artists": "MXZI, Deno",
  "genres": "Brazilian Phonk",
  "versions": "Regular",
  "preview_url": "https://ncsmusic.s3.eu-west-1.amazonaws.com/tracks/000/002/003/favela-1762477273-EdjAqE9a7B.mp3",
  "cover_url": "https://ncsmusic.s3.eu-west-1.amazonaws.com/tracks/000/002/003/100x100/favela-1762477269-WMI8O3pkwV.png",
  "release_date": "2025-11-07",
  "track_url": "https://ncs.io/FAVELA",
  "source": "https://ncs.io/?display=list&page=1"
}
```

#### Example — track\_detail (with download URL)

```json
{
  "type": "track_detail",
  "track_id": "af3e020d-b90d-439a-9106-76eb863784eb",
  "title": "Dreamer",
  "description": "Listen to Dreamer by Alan Walker on NCS - House, Energetic, Epic, Euphoric, Glamorous, Quirky, Restless, Romantic",
  "artists": [
    "Alan Walker"
  ],
  "artist_urls": [
    "https://ncs.io/artist/13/alan-walker"
  ],
  "genres": "House",
  "preview_url": "https://ncsmusic.s3.eu-west-1.amazonaws.com/tracks/000/001/378/dreamer-1680825645-w02oSTah2D.mp3",
  "download_url": "https://ncs.io/track/download/af3e020d-b90d-439a-9106-76eb863784eb",
  "cover_url": "https://ncsmusic.s3.eu-west-1.amazonaws.com/tracks/000/001/378/1000x0/dreamer-1680825643-xI8uIuthxk.jpg",
  "track_url": "https://ncs.io/dreamer"
}
```

#### Example — artist

```json
{
  "type": "artist",
  "artist_id": 13,
  "artist_name": "Alan Walker",
  "description": "",
  "genres": "House, Melodic Dubstep,",
  "cover_url": "https://ncsmusic.s3.eu-west-1.amazonaws.com/artists/000/000/013/1000x0/1680848518_PmrrHgs9Ro_Screenshot-2023-04-07-at-07.19.27.png",
  "artist_url": "https://ncs.io/artist/13/alan-walker"
}
```

### Data fields

| Field | Type | Present in |
|---|---|---|
| `type` | string | All records |
| `track_id` | string | `track`, `popular_track`, `track_detail`, `search_result`, `artist_track` |
| `title` | string | `track`, `popular_track`, `track_detail`, `search_result`, `artist_track` |
| `artists` | string / array | `track`, `popular_track`, `track_detail`, `search_result`, `artist_track` |
| `genres` | string | `track`, `popular_track`, `track_detail`, `search_result`, `artist_track`, `artist` |
| `versions` | string | `popular_track`, `search_result`, `artist_track` |
| `moods` | array | `search_result`, `artist_track` |
| `release_date` | string | `popular_track` (ISO format `YYYY-MM-DD`), `search_result`, `artist_track` (display format `D Mon YYYY`) |
| `preview_url` | string | `track`, `popular_track`, `track_detail`, `search_result`, `artist_track` |
| `download_url` | string | `track_detail` — requires `crawl_track_pages: true` |
| `cover_url` | string | `popular_track`, `track_detail`, `search_result`, `artist_track`, `artist` |
| `track_url` | string | `track`, `popular_track`, `track_detail`, `search_result`, `artist_track` |
| `source` | string | `track`, `popular_track` — the library page URL where the track was found |
| `artist_id` | integer | `artist`, `artist_track` |
| `artist_name` | string | `artist`, `artist_track` |
| `artist_url` | string | `artist` |
| `artist_urls` | array | `track_detail` |
| `description` | string | `track_detail`, `artist` |
| `genre_id` | integer | `genre` |
| `genre_name` | string | `genre` |
| `mood_id` | integer | `mood` |
| `mood_name` | string | `mood` |

### Tips

**Get download URLs** — they are only available in `track_detail` records. Enable `crawl_track_pages: true` in `library` or `full` mode. This visits one additional page per track, so factor that into your compute unit estimate.

**Popular vs Recent** — the library page has two separate sections. The 5 Popular Releases are NCS-curated featured tracks, always the same regardless of which page you crawl; they are collected once from page 1. The Recent Releases table is the paginated chronological catalogue. Disable either with `scrape_popular: false` or `scrape_recent: false` if you only need one.

**`release_date` format varies by record type** — `popular_track` records store the date in ISO format (`2025-11-07`, from a hidden HTML attribute), while `search_result` and `artist_track` records use the display format shown on the page (`16 Jun 2026`). Normalise them in your pipeline if you need to compare or sort across types.

**Filter by name, not ID** — use `genre_name` and `mood_name` (e.g. `"drum & bass"`, `"dark"`) instead of raw numeric IDs. Run `genres` or `moods` mode first to see every valid value.

**Limit compute units** — keep `crawl_track_pages: false` (the default) unless you need download links. Reduce `max_pages` or `max_search_pages` for quick test runs.

**Full artist discography** — use `artist` mode with a direct artist URL and enable `crawl_artist_tracks: true` to get their complete track listing in a single request.

**Avoid duplicate data** — when `crawl_track_pages: true`, the library handler skips pushing basic `track` records and queues individual track pages instead, so each track appears exactly once as a `track_detail`.

### FAQ

**Is scraping NCS legal?**
All data collected is publicly visible in any browser. This Actor does not bypass authentication, paywalls, or any access controls. Always respect NCS's Terms of Service and use collected data responsibly.

**Why is `download_url` null in my results?**
Download URLs are only extracted when visiting individual track pages. Set `crawl_track_pages: true` in `library` or `full` mode, or use `track` mode with a direct URL.

**Can I filter by multiple genres or moods at once?**
No — NCS's search accepts one genre and one mood filter per request. Run the Actor multiple times with different filters to build a combined dataset.

**The `artists` field is a string in some records and an array in others — why?**
Library listings and search results store artists as a raw comma-separated string from the page's data attribute. Individual track pages (`track_detail`) parse them into a proper array with separate `artist_urls`. Use `track_detail` records (via `crawl_track_pages: true`) when you need structured artist data.

For bugs or feature requests, use the Issues tab on the Actor's page.

### Resources

- [Apify SDK for Python](https://docs.apify.com/sdk/python)
- [Crawlee for Python](https://crawlee.dev/python/)
- [Apify Platform documentation](https://docs.apify.com/platform)
- [Join the Apify developer community on Discord](https://discord.com/invite/jyEM2PRvMU)

# Actor input Schema

## `mode` (type: `string`):

Crawl target. Use 'library' to page through the full NCS music catalogue, 'search' to query by keyword/genre/mood, 'artists' for all artist profiles, 'full' for library + artists in one run, 'track' / 'artist' for a single item by URL, 'artist\_tracks' for all tracks by a named artist, or 'genres' / 'moods' to retrieve the full list of filter IDs and names.

## `max_pages` (type: `integer`):

Maximum number of music library pages to crawl. Applies to 'library' and 'full' modes only. Each page contains ~18 tracks.

## `crawl_track_pages` (type: `boolean`):

Visit each individual track page to collect the download URL and full description. Applies to 'library' and 'full' modes. Enabling this multiplies the number of requests by the number of tracks found. When enabled, basic listing records are replaced by richer 'track\_detail' records to avoid duplicates.

## `crawl_artist_pages` (type: `boolean`):

Visit artist profile pages discovered while crawling the library. Applies to 'library' and 'full' modes. Produces 'artist' records with bio, genres, and cover image.

## `crawl_artist_tracks` (type: `boolean`):

Extract the track listing from each artist's profile page. Applies to 'artist' and 'artists' modes (or 'library'/'full' when 'crawl\_artist\_pages' is also enabled). Produces 'artist\_track' records.

## `scrape_popular` (type: `boolean`):

Collect the 5 featured 'Popular Releases' shown at the top of the library page. These are the same tracks on every page, so they are only scraped once from page 1. Produces 'popular\_track' records (with 'track\_detail' records instead if 'crawl\_track\_pages' is enabled). Applies to 'library' and 'full' modes.

## `scrape_recent` (type: `boolean`):

Collect tracks from the 'Recent Releases' table — the paginated listing of newest NCS additions. Produces 'track' records (or 'track\_detail' records if 'crawl\_track\_pages' is enabled). Applies to 'library' and 'full' modes.

## `query` (type: `string`):

Keyword, track title, or artist name to search for. Applies to 'search' mode.

## `artist` (type: `string`):

Artist name to look up. Applies to 'artist\_tracks' mode.

## `track_url` (type: `string`):

Direct NCS track URL (e.g. https://ncs.io/dreamer). Applies to 'track' mode.

## `genre` (type: `string`):

Numeric NCS genre ID to filter results. Use 'genres' mode to retrieve the full list of IDs. Prefer 'genre\_name' for readability — both cannot be used simultaneously; 'genre\_name' takes precedence. Applies to 'search' mode.

## `genre_name` (type: `string`):

Genre filter by human-readable name (e.g. 'drum & bass', 'future bass'). Resolved to an ID automatically. Run 'genres' mode to see all valid values. Takes precedence over 'genre' if both are set. Applies to 'search' mode.

## `mood` (type: `string`):

Numeric NCS mood ID to filter results. Use 'moods' mode to retrieve the full list of IDs. Prefer 'mood\_name' for readability — both cannot be used simultaneously; 'mood\_name' takes precedence. Applies to 'search' mode.

## `mood_name` (type: `string`):

Mood filter by human-readable name (e.g. 'energetic', 'dark'). Resolved to an ID automatically. Run 'moods' mode to see all valid values. Takes precedence over 'mood' if both are set. Applies to 'search' mode.

## `version` (type: `string`):

Filter by track version. 'regular' returns standard releases, 'instrumental' returns instrumental-only tracks, 'regular-instrumental' returns both. Applies to 'search' mode.

## `max_search_pages` (type: `integer`):

Maximum number of search result pages to fetch. Applies to 'search' mode only. Each page returns up to 18 tracks.

## `artist_url` (type: `string`):

Direct NCS artist profile URL (e.g. https://ncs.io/artist/13/alan-walker). Applies to 'artist' mode.

## Actor input object example

```json
{
  "mode": "library",
  "max_pages": 5,
  "crawl_track_pages": false,
  "crawl_artist_pages": true,
  "crawl_artist_tracks": false,
  "scrape_popular": true,
  "scrape_recent": true,
  "query": "",
  "artist": "",
  "track_url": "",
  "genre": "",
  "genre_name": "",
  "mood": "",
  "mood_name": "",
  "version": "regular",
  "max_search_pages": 1,
  "artist_url": ""
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("futuristforever/ncs-music-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("futuristforever/ncs-music-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 '{}' |
apify call futuristforever/ncs-music-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NCS Music Scraper",
        "description": "Scrape tracks, artists, genres, moods, search results, and track metadata from NoCopyrightSounds (NCS).",
        "version": "0.1",
        "x-build-id": "quPBPo4OxgIxWXDzk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/futuristforever~ncs-music-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-futuristforever-ncs-music-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/futuristforever~ncs-music-scraper/runs": {
            "post": {
                "operationId": "runs-sync-futuristforever-ncs-music-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/futuristforever~ncs-music-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-futuristforever-ncs-music-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "library",
                            "artists",
                            "full",
                            "search",
                            "genres",
                            "moods",
                            "artist_tracks",
                            "track",
                            "artist"
                        ],
                        "type": "string",
                        "description": "Crawl target. Use 'library' to page through the full NCS music catalogue, 'search' to query by keyword/genre/mood, 'artists' for all artist profiles, 'full' for library + artists in one run, 'track' / 'artist' for a single item by URL, 'artist_tracks' for all tracks by a named artist, or 'genres' / 'moods' to retrieve the full list of filter IDs and names.",
                        "default": "library"
                    },
                    "max_pages": {
                        "title": "Max Library Pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of music library pages to crawl. Applies to 'library' and 'full' modes only. Each page contains ~18 tracks.",
                        "default": 5
                    },
                    "crawl_track_pages": {
                        "title": "Crawl Track Pages",
                        "type": "boolean",
                        "description": "Visit each individual track page to collect the download URL and full description. Applies to 'library' and 'full' modes. Enabling this multiplies the number of requests by the number of tracks found. When enabled, basic listing records are replaced by richer 'track_detail' records to avoid duplicates.",
                        "default": false
                    },
                    "crawl_artist_pages": {
                        "title": "Crawl Artist Pages",
                        "type": "boolean",
                        "description": "Visit artist profile pages discovered while crawling the library. Applies to 'library' and 'full' modes. Produces 'artist' records with bio, genres, and cover image.",
                        "default": true
                    },
                    "crawl_artist_tracks": {
                        "title": "Crawl Artist Tracks",
                        "type": "boolean",
                        "description": "Extract the track listing from each artist's profile page. Applies to 'artist' and 'artists' modes (or 'library'/'full' when 'crawl_artist_pages' is also enabled). Produces 'artist_track' records.",
                        "default": false
                    },
                    "scrape_popular": {
                        "title": "Scrape Popular Releases",
                        "type": "boolean",
                        "description": "Collect the 5 featured 'Popular Releases' shown at the top of the library page. These are the same tracks on every page, so they are only scraped once from page 1. Produces 'popular_track' records (with 'track_detail' records instead if 'crawl_track_pages' is enabled). Applies to 'library' and 'full' modes.",
                        "default": true
                    },
                    "scrape_recent": {
                        "title": "Scrape Recent Releases",
                        "type": "boolean",
                        "description": "Collect tracks from the 'Recent Releases' table — the paginated listing of newest NCS additions. Produces 'track' records (or 'track_detail' records if 'crawl_track_pages' is enabled). Applies to 'library' and 'full' modes.",
                        "default": true
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword, track title, or artist name to search for. Applies to 'search' mode.",
                        "default": ""
                    },
                    "artist": {
                        "title": "Artist Name",
                        "type": "string",
                        "description": "Artist name to look up. Applies to 'artist_tracks' mode.",
                        "default": ""
                    },
                    "track_url": {
                        "title": "Track URL",
                        "type": "string",
                        "description": "Direct NCS track URL (e.g. https://ncs.io/dreamer). Applies to 'track' mode.",
                        "default": ""
                    },
                    "genre": {
                        "title": "Genre ID",
                        "type": "string",
                        "description": "Numeric NCS genre ID to filter results. Use 'genres' mode to retrieve the full list of IDs. Prefer 'genre_name' for readability — both cannot be used simultaneously; 'genre_name' takes precedence. Applies to 'search' mode.",
                        "default": ""
                    },
                    "genre_name": {
                        "title": "Genre Name",
                        "type": "string",
                        "description": "Genre filter by human-readable name (e.g. 'drum & bass', 'future bass'). Resolved to an ID automatically. Run 'genres' mode to see all valid values. Takes precedence over 'genre' if both are set. Applies to 'search' mode.",
                        "default": ""
                    },
                    "mood": {
                        "title": "Mood ID",
                        "type": "string",
                        "description": "Numeric NCS mood ID to filter results. Use 'moods' mode to retrieve the full list of IDs. Prefer 'mood_name' for readability — both cannot be used simultaneously; 'mood_name' takes precedence. Applies to 'search' mode.",
                        "default": ""
                    },
                    "mood_name": {
                        "title": "Mood Name",
                        "type": "string",
                        "description": "Mood filter by human-readable name (e.g. 'energetic', 'dark'). Resolved to an ID automatically. Run 'moods' mode to see all valid values. Takes precedence over 'mood' if both are set. Applies to 'search' mode.",
                        "default": ""
                    },
                    "version": {
                        "title": "Version",
                        "enum": [
                            "regular",
                            "instrumental",
                            "regular-instrumental"
                        ],
                        "type": "string",
                        "description": "Filter by track version. 'regular' returns standard releases, 'instrumental' returns instrumental-only tracks, 'regular-instrumental' returns both. Applies to 'search' mode.",
                        "default": "regular"
                    },
                    "max_search_pages": {
                        "title": "Max Search Pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of search result pages to fetch. Applies to 'search' mode only. Each page returns up to 18 tracks.",
                        "default": 1
                    },
                    "artist_url": {
                        "title": "Artist URL",
                        "type": "string",
                        "description": "Direct NCS artist profile URL (e.g. https://ncs.io/artist/13/alan-walker). Applies to 'artist' mode.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
