# SoundCloud Scraper (`goat255/soundcloud-scraper`) Actor

Scrape SoundCloud tracks, artist profiles, and search results without a login. Pull an artist's tracks by profile, fetch individual track links, or run keyword searches. Walks pagination up to your chosen limit.

- **URL**: https://apify.com/goat255/soundcloud-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Scraper

Scrape public SoundCloud tracks, artist profiles, and search results with no login and no API key. Give it artist profile links, individual track links, or keyword search terms and it returns clean, structured rows with play counts, likes, reposts, comments, genre, tags, artwork, and full artist details.

### What it does

- **Artist tracks by profile.** Pass a profile URL or a bare handle and pull every public track an artist has uploaded, paginated automatically up to your limit.
- **Profile details.** Optionally emit one profile row per artist with username, display name, bio, follower count, following count, track count, playlist count, and verified status.
- **Single tracks by URL.** Pass individual track links and get one clean, fully detailed row per track.
- **Keyword search.** Run text searches across public tracks and collect the results across multiple pages.
- **Rich metrics on every track.** Play count, likes, reposts, comments, downloads, duration, genre, tags, license, release date, artwork, and the uploading artist.
- **No login, no API key.** Works straight out of the box. Just provide profiles, track links, or search terms.

### Use cases

- **Artist and A&R research.** Track an artist's full catalog, play counts, and engagement to spot rising talent or evaluate a signing.
- **Market and genre research.** Search a genre or keyword and analyze which tracks, sounds, and creators are gaining traction.
- **Influencer and creator discovery.** Find creators by keyword, then pull their follower counts and engagement to build outreach lists.
- **Catalog monitoring.** Re-run on a schedule to watch how play counts, likes, and comments change over time for a set of tracks or artists.
- **Dataset building.** Assemble structured music metadata for dashboards, recommendation experiments, or trend reports.

### Input

| Field | Type | Description |
|---|---|---|
| `profileUrls` | array | Artist profiles to pull tracks from. A full profile link (`https://soundcloud.com/example_artist`) or a bare handle (`example_artist`, `@example_artist`). |
| `trackUrls` | array | Individual track links to fetch as single rows. |
| `searchQueries` | array | Keyword searches to run across public tracks (for example `lofi beats`, `deep house`). |
| `maxTracksPerSource` | integer | Maximum tracks returned per profile or search query. Pagination is walked across multiple pages until this is reached or the source is exhausted. Default `100`. |
| `includeProfile` | boolean | When on, each profile also emits one profile row (username, bio, follower and track counts) before its tracks. Default `true`. |
| `concurrency` | integer | How many sources to process in parallel. Default `5`. |
| `proxyConfig` | object | Optional proxy configuration. The public endpoints do not require a proxy, but you may route through one if you wish. |

#### Example input

```json
{
  "profileUrls": ["https://soundcloud.com/example_artist"],
  "searchQueries": ["lofi beats"],
  "maxTracksPerSource": 200,
  "includeProfile": true,
  "concurrency": 5
}
````

### Output

Each result is a clean, flat row. Track rows look like this:

```json
{
  "type": "track",
  "id": 264023874,
  "url": "https://soundcloud.com/example_artist/example-track",
  "title": "Example Track",
  "artistUsername": "example_artist",
  "genre": "Electronic",
  "playbackCount": 74383945,
  "likesCount": 1091998,
  "repostsCount": 70290,
  "commentCount": 25784,
  "downloadCount": 0,
  "durationMs": 273849,
  "fullDurationMs": 273892,
  "description": "An example track description.",
  "tags": ["example", "demo"],
  "license": "all-rights-reserved",
  "artistUrl": "https://soundcloud.com/example_artist",
  "artistId": 1234567,
  "artistFollowersCount": 50000,
  "artistVerified": true,
  "artworkUrl": "https://example.com/artwork-t500x500.jpg",
  "waveformUrl": "https://example.com/waveform.json",
  "createdAt": "2026-06-01T12:00:00Z",
  "releaseDate": "2026-06-01T00:00:00Z",
  "lastModified": "2026-06-02T08:30:00Z",
  "isPublic": true,
  "streamable": true,
  "downloadable": false
}
```

When `includeProfile` is on, each artist also produces one profile row:

```json
{
  "type": "profile",
  "id": 1234567,
  "url": "https://soundcloud.com/example_artist",
  "username": "example_artist",
  "fullName": "Example Artist",
  "verified": true,
  "followersCount": 50000,
  "followingsCount": 120,
  "trackCount": 84,
  "playlistCount": 6,
  "likesCount": 310,
  "commentsCount": 0,
  "description": "Example artist bio.",
  "city": "Berlin",
  "countryCode": "DE",
  "avatarUrl": "https://example.com/avatar-large.jpg",
  "lastModified": "2026-04-16T00:00:01Z"
}
```

**Key fields.** `type` tells track rows apart from profile rows. `playbackCount`, `likesCount`, `repostsCount`, and `commentCount` are the engagement metrics. `genre`, `tags`, and `description` are creator-supplied and can be empty when the uploader left them blank. `artistFollowersCount` and `artistVerified` describe the uploading artist on every track row.

### FAQ

**Do I need a SoundCloud login or API key?**
No. There is no account, password, or API key. Provide profiles, track links, or search terms and run it.

**How much does it cost?**
You are billed per result row through Apify's pay-per-event pricing. A run that returns no rows costs nothing for results. See the pricing tab on this Actor's page for the current rate.

**How many results can I get?**
Set `maxTracksPerSource` to control the cap per profile or search query. Pagination is walked across as many pages as needed to reach your target or until the source has no more public tracks. You can run many profiles, track links, and search queries in a single run.

**How fast is it?**
Sources are processed in parallel (set `concurrency`, default 5). Throughput scales with how many profiles and queries you supply and your per-source limit.

**Why are `genre`, `tags`, or `description` sometimes empty?**
Those fields are filled in by the uploader. When a creator leaves them blank, the row carries an empty value. Numeric metrics, URLs, IDs, and dates are populated whenever the track is public.

**Can I use a proxy?**
Yes. A proxy is optional via `proxyConfig`. The public endpoints do not require one.

**Can I scrape private or unlisted content?**
No. Only public tracks, profiles, and search results are returned.

# Actor input Schema

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

SoundCloud artist profiles to pull tracks from. A full profile link or a bare handle. Example: https://soundcloud.com/example\_artist, example\_artist, @example\_artist.

## `trackUrls` (type: `array`):

Individual track links to fetch. One clean row per link. Example: https://soundcloud.com/example\_artist/example-track.

## `searchQueries` (type: `array`):

Keyword searches to run across public tracks. Example: lofi beats, deep house.

## `maxTracksPerSource` (type: `integer`):

Cap on tracks returned per profile or query. Pagination is walked across multiple pages until this is reached or the source is exhausted.

## `includeProfile` (type: `boolean`):

When on, each profile also emits one profile record (username, bio, follower and track counts) before its tracks.

## `concurrency` (type: `integer`):

How many sources to process in parallel.

## `proxyConfig` (type: `object`):

Optional proxy. The public read endpoints do not require a proxy, but you may route through one if you wish.

## Actor input object example

```json
{
  "profileUrls": [
    "https://soundcloud.com/example_artist"
  ],
  "trackUrls": [],
  "searchQueries": [],
  "maxTracksPerSource": 100,
  "includeProfile": true,
  "concurrency": 5,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "profileUrls": [
        "https://soundcloud.com/example_artist"
    ],
    "trackUrls": [],
    "searchQueries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/soundcloud-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 = {
    "profileUrls": ["https://soundcloud.com/example_artist"],
    "trackUrls": [],
    "searchQueries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("goat255/soundcloud-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 '{
  "profileUrls": [
    "https://soundcloud.com/example_artist"
  ],
  "trackUrls": [],
  "searchQueries": []
}' |
apify call goat255/soundcloud-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SoundCloud Scraper",
        "description": "Scrape SoundCloud tracks, artist profiles, and search results without a login. Pull an artist's tracks by profile, fetch individual track links, or run keyword searches. Walks pagination up to your chosen limit.",
        "version": "0.1",
        "x-build-id": "409dVv3cpHRhsxeJj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~soundcloud-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-soundcloud-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/goat255~soundcloud-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-soundcloud-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/goat255~soundcloud-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-soundcloud-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": {
                    "profileUrls": {
                        "title": "Profile URLs (artist mode)",
                        "type": "array",
                        "description": "SoundCloud artist profiles to pull tracks from. A full profile link or a bare handle. Example: https://soundcloud.com/example_artist, example_artist, @example_artist.",
                        "default": [
                            "__healthcheck__"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "trackUrls": {
                        "title": "Track URLs (single track mode)",
                        "type": "array",
                        "description": "Individual track links to fetch. One clean row per link. Example: https://soundcloud.com/example_artist/example-track.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries (search mode)",
                        "type": "array",
                        "description": "Keyword searches to run across public tracks. Example: lofi beats, deep house.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxTracksPerSource": {
                        "title": "Max tracks per source",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Cap on tracks returned per profile or query. Pagination is walked across multiple pages until this is reached or the source is exhausted.",
                        "default": 100
                    },
                    "includeProfile": {
                        "title": "Include a profile header row",
                        "type": "boolean",
                        "description": "When on, each profile also emits one profile record (username, bio, follower and track counts) before its tracks.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many sources to process in parallel.",
                        "default": 5
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. The public read endpoints do not require a proxy, but you may route through one if you wish.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
