# SoundCloud Tracks Search Scraper (`fetch_cat/soundcloud-tracks-search-scraper`) Actor

Scrape public SoundCloud tracks, artist metadata, engagement counts, genres, tags, and profile track lists for music research.

- **URL**: https://apify.com/fetch\_cat/soundcloud-tracks-search-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 track saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## SoundCloud Tracks Search Scraper

Scrape public SoundCloud track search results and public profile tracks for music research, creator discovery, and campaign monitoring.

### What does SoundCloud Tracks Search Scraper do?

This actor collects public track metadata from SoundCloud.

It can run keyword searches such as `lofi beats`, `indie pop`, or `techno remix`.

It can also collect tracks from public SoundCloud profile URLs.

The output is a clean dataset with track, artist, engagement, and source-context fields.

### Who is it for?

Music marketers use it to discover tracks and artists around target genres.

Creator agencies use it to monitor public creator catalogs.

Playlist researchers use it to find songs and artists with engagement signals.

Trend analysts use it to compare public search results over time.

Content teams use it to build research lists for outreach and editorial planning.

### Why use this actor?

- 🎧 Collect track metadata without manual copy-paste.
- 📈 Capture engagement metrics such as plays, likes, reposts, and comments.
- 👤 Include artist profile metadata in each row.
- 🔎 Combine search queries and profile URLs in one run.
- 📦 Export results as JSON, CSV, Excel, or via API.

### What data can it extract?

| Field group | Examples |
| --- | --- |
| Track identity | track ID, trackTitle, URL, permalink |
| Track metadata | description, created date, duration, genre, tags |
| Engagement | plays, likes, reposts, comments, downloads |
| Media | artwork URL, waveform URL |
| Publisher metadata | artist, album title, ISRC, release title |
| Artist profile | username, profile URL, avatar, country, followers |
| Run context | source type, query, profile URL, rank, scraped time |

### How much does it cost to scrape SoundCloud tracks?

The actor uses pay-per-event pricing.

There is a small run-start event and a per-track saved event.

The default target is about $0.50 per 1,000 track records before volume discounts.

Exact pricing is shown on the Apify actor page before you start a run.

### Input overview

Use `queries` for SoundCloud search keywords.

Use `profileUrls` for public SoundCloud profile pages.

Use `maxItems` to cap the total number of track records.

Proxy settings are optional and normally not needed.

### Example input

```json
{
  "queries": ["lofi beats"],
  "profileUrls": [{ "url": "https://soundcloud.com/chillhopdotcom" }],
  "maxItems": 25,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Output example

```json
{
  "trackId": 123456,
  "trackTitle": "Example Track",
  "url": "https://soundcloud.com/artist/example-track",
  "artistUsername": "artist",
  "playbackCount": 10000,
  "likesCount": 500,
  "sourceType": "search",
  "source": "lofi beats",
  "rank": 1,
  "scrapedAt": "2026-07-05T00:00:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Add one or more search queries.
3. Optionally add public SoundCloud profile URLs.
4. Set `maxItems`.
5. Click **Start**.
6. Download the dataset when the run finishes.

### Search query tips

Use genre terms such as `ambient`, `drum and bass`, or `house`.

Use campaign terms such as brand names, moods, or event names.

Use artist names when you want search-result context rather than only profile tracks.

Run the same query regularly to monitor changes over time.

### Profile URL tips

Use public SoundCloud profile URLs.

The actor returns public tracks from those profiles.

Private, deleted, or login-only tracks are not included.

For large profiles, increase `maxItems`.

### Integrations

Send datasets to Google Sheets for review lists.

Export CSV files for CRM enrichment.

Use webhooks to trigger downstream workflows after each run.

Use the Apify API to schedule recurring searches.

Connect results to BI tools for trend dashboards.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/soundcloud-tracks-search-scraper').call({
  queries: ['lofi beats'],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/soundcloud-tracks-search-scraper').call(run_input={
    'queries': ['lofi beats'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~soundcloud-tracks-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["lofi beats"],"maxItems":25}'
```

### MCP usage

Use Apify MCP with this actor in Claude Code or Claude Desktop.

MCP tool URL:

`https://mcp.apify.com/?tools=fetch_cat/soundcloud-tracks-search-scraper`

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/soundcloud-tracks-search-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/soundcloud-tracks-search-scraper"
    }
  }
}
```

Example prompts:

- "Find 25 public SoundCloud tracks for lofi beats and summarize the top artists."
- "Scrape this SoundCloud profile and make a table of tracks by play count."
- "Run the SoundCloud scraper weekly and compare engagement trends."

### Data quality notes

Counts come from public SoundCloud metadata at scrape time.

Some tracks may have missing descriptions, genre, or artwork.

Engagement numbers can change after the run finishes.

The actor keeps numeric counts as numbers where SoundCloud provides them.

### Limits

The actor collects public metadata only.

It does not download audio.

It does not bypass private content.

It does not require user login.

Very large runs may take longer because SoundCloud results are paginated.

### Legality

This actor is designed for public web data.

You are responsible for using the results lawfully and respecting applicable terms, privacy rules, and intellectual-property rights.

Do not use scraped data for spam, harassment, or unauthorized downloading.

### FAQ

#### Can this actor download SoundCloud audio?

No. It extracts public track metadata only.

#### Can I combine searches and profiles?

Yes. Add both `queries` and `profileUrls`; `maxItems` is shared across all sources.

### Troubleshooting

#### Why did my run return fewer tracks than requested?

SoundCloud may have fewer public tracks for the query or profile, or duplicate tracks may be removed across combined sources.

#### Why are some fields empty?

Some artists do not publish every metadata field. Empty optional fields are normal.

#### Should I use a proxy?

Usually no. Leave proxy settings disabled unless you have a specific network-routing need.

### Related scrapers

- https://apify.com/fetch\_cat/instagram-profile-posts-scraper
- https://apify.com/fetch\_cat/tiktok-video-scraper
- https://apify.com/fetch\_cat/youtube-community-posts-scraper

### Changelog

Initial version: public track search and public profile track extraction.

### Support

If a run fails, include the run ID and input when reporting the issue.

### Field reference

`trackId`

`trackTitle`

`url`

`permalink`

`apiUri`

`description`

`createdAt`

`displayDate`

`durationMs`

`genre`

`tags`

`artworkUrl`

`waveformUrl`

`playbackCount`

`likesCount`

`repostsCount`

`commentCount`

`downloadCount`

`downloadable`

`streamable`

`license`

`publisherArtist`

`publisherAlbumTitle`

`publisherIsrc`

`publisherReleaseTitle`

`artistId`

`artistUsername`

`artistFullName`

`artistProfileUrl`

`artistAvatarUrl`

`artistCity`

`artistCountry`

`artistFollowersCount`

`artistTrackCount`

`artistVerified`

`sourceType`

`source`

`query`

`profileUrl`

`rank`

`scrapedAt`

# Actor input Schema

## `queries` (type: `array`):

SoundCloud track search keywords, artists, genres, moods, or campaign terms.

## `profileUrls` (type: `array`):

Public SoundCloud profile URLs. The actor returns public tracks from these profiles.

## `maxItems` (type: `integer`):

Total number of track records to save across all queries and profiles.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy settings. Leave empty unless your network needs proxy routing.

## Actor input object example

```json
{
  "queries": [
    "lofi beats"
  ],
  "profileUrls": [
    {
      "url": "https://soundcloud.com/chillhopdotcom"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "lofi beats"
    ],
    "profileUrls": [
        {
            "url": "https://soundcloud.com/chillhopdotcom"
        }
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/soundcloud-tracks-search-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 = {
    "queries": ["lofi beats"],
    "profileUrls": [{ "url": "https://soundcloud.com/chillhopdotcom" }],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/soundcloud-tracks-search-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 '{
  "queries": [
    "lofi beats"
  ],
  "profileUrls": [
    {
      "url": "https://soundcloud.com/chillhopdotcom"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/soundcloud-tracks-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SoundCloud Tracks Search Scraper",
        "description": "Scrape public SoundCloud tracks, artist metadata, engagement counts, genres, tags, and profile track lists for music research.",
        "version": "0.1",
        "x-build-id": "l8lJv61VjVdwdJCWA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~soundcloud-tracks-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-soundcloud-tracks-search-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/fetch_cat~soundcloud-tracks-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-soundcloud-tracks-search-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/fetch_cat~soundcloud-tracks-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-soundcloud-tracks-search-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": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "SoundCloud track search keywords, artists, genres, moods, or campaign terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "profileUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "Public SoundCloud profile URLs. The actor returns public tracks from these profiles.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum tracks",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Total number of track records to save across all queries and profiles.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Leave empty unless your network needs proxy routing."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```