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

Scrape SoundCloud tracks, playlists, and artist profiles by search query or URL: plays, likes, reposts, comments, genre, tags, ISRC, followers, and more. No login or API key. Export as JSON, CSV, or Excel.

- **URL**: https://apify.com/parsebird/soundcloud-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.09 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

**SoundCloud Scraper** extracts structured data from [SoundCloud](https://soundcloud.com) — **tracks**, **playlists**, and **artist profiles** — by search query or by URL. It reads SoundCloud's own public `api-v2` endpoints, the same ones the website uses, so there is **no login, no API key, and no browser**. Get play counts, likes, reposts, comments, genre, tags, ISRC codes, waveform URLs, follower counts, and more.

<table><tr>
<td style="border-left:4px solid #FF5500;padding:12px 16px;font-weight:600">
Six modes in one SoundCloud scraper — search tracks, playlists, or users, or pass a track, playlist, or artist URL. Playlist mode can expand every public child track; track results carry the creator's profile stats.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Actor: parsebird/soundcloud-scraper (SoundCloud Scraper on Apify)
Purpose: scrape SoundCloud tracks, playlists, and artist/user profiles from SoundCloud's public api-v2 (no auth).
Call it with ApifyClient. Example (Python):
  from apify_client import ApifyClient
  client = ApifyClient("<APIFY_TOKEN>")
  run = client.actor("parsebird/soundcloud-scraper").call(run_input={
      "mode": "searchTracks",          # searchTracks | searchPlaylists | searchUsers | trackUrl | playlistUrl | userUrl
      "searchQueries": ["ambient techno", "dark jazz"],  # search modes: one term per item
      "startUrls": ["https://soundcloud.com/flume"],     # URL modes: track, playlist (/sets/), or profile URLs
      "maxResults": 100,               # per query / URL; 0 = unlimited. In playlistUrl mode limits child tracks
      "includeUserDetails": True,      # attach creator follower count + verified status to each track
      "includePlaylistTracks": False   # playlistUrl mode: emit public child tracks after the playlist row
  })
  for item in client.dataset(run["defaultDatasetId"]).iterate_items():
      print(item)
Output rows have a "type" field: "track" (title, url, genre, tagList, duration, playbackCount, likesCount,
  repostsCount, commentCount, license, isrc, waveformUrl, userName, userFollowersCount, userVerified),
  "playlist" (title, url, trackCount, duration, likesCount, isAlbum, publishedAt, userName), or
  "user" (username, fullName, url, followersCount, followingsCount, trackCount, playlistCount, verified, isPro).
API docs: https://docs.apify.com/api/v2  |  Token: https://console.apify.com/account/integrations
```

### What does SoundCloud Scraper do?

SoundCloud Scraper turns any SoundCloud search or URL into a clean dataset. Pick one of six modes per run:

- 🔎 **Search tracks** — find tracks by genre, mood, artist, or any keyword and get full track metadata with play, like, repost, and comment counts.
- 📋 **Search playlists** — discover playlists and albums matching a query, with track counts, total duration, and creator.
- 👤 **Search users / artists** — find creators by name or keyword and get their follower counts, upload counts, location, and verified/Pro status.
- 🎵 **Track by URL** — pass one or many `soundcloud.com/artist/track` URLs and get a row per track.
- 📀 **Playlist by URL** — pass a `/sets/` URL to get the playlist metadata, and optionally every public track inside it.
- 🎤 **User / artist by URL** — pass a profile URL to get the artist profile plus their uploaded tracks.

Platform features: [schedule](https://docs.apify.com/platform/schedules) runs to track play-count and follower growth over time, call the actor from the [Apify API](https://docs.apify.com/api/v2), pipe results into [integrations](https://docs.apify.com/platform/integrations) (Zapier, Make, n8n, Slack, Google Sheets), and export to **JSON, CSV, or Excel**.

### Why scrape SoundCloud?

- **A\&R and talent scouting** — surface fast-growing artists by play count, repost velocity, and genre.
- **Playlist and catalog research** — map which tracks sit in the biggest playlists and albums.
- **Music analytics and monitoring** — poll a set of tracks or artists on a schedule and chart plays, likes, and followers.
- **Rights and metadata work** — pull ISRC codes, license types, release dates, and label names in bulk.
- **Dataset building** — assemble genre- or mood-labelled track datasets for research or machine learning.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mode` | string | **Yes** | `searchTracks` | `searchTracks`, `searchPlaylists`, `searchUsers`, `trackUrl`, `playlistUrl`, or `userUrl` |
| `searchQueries` | array | For search modes | `[]` | Search terms, one per item |
| `startUrls` | array | For URL modes | `[]` | SoundCloud track, playlist (`/sets/`), or profile URLs |
| `maxResults` | integer | No | `100` | Max items per query or URL. `0` = unlimited. In `playlistUrl` mode, limits child tracks per playlist |
| `includeUserDetails` | boolean | No | `true` | Attach the creator's follower count and verified status to each track result |
| `includePlaylistTracks` | boolean | No | `false` | In `playlistUrl` mode, emit each public child track after the playlist row |
| `proxyConfiguration` | object | No | Apify Proxy | Optional — SoundCloud works from Apify's datacenter proxy |

### What data can you extract from SoundCloud?

**Track data** (`type: "track"`)

| Field | Description |
|-------|-------------|
| `title` | Track title |
| `url` | Full SoundCloud track URL |
| `artworkUrl` | Cover art image URL |
| `description` | Track description / tracklist |
| `genre` | Genre classification |
| `tagList` | Array of tags |
| `duration` | Duration in milliseconds |
| `playbackCount` | Total plays |
| `likesCount` | Total likes |
| `repostsCount` | Total reposts |
| `commentCount` | Total comments |
| `downloadCount` / `downloadable` | Download count and whether download is enabled |
| `streamable` | Whether streaming is available |
| `license` | License type (e.g. `all-rights-reserved`, `cc-by`) |
| `releaseDate` / `createdAt` | Original release date and upload date |
| `isrc` | ISRC music identifier code |
| `waveformUrl` | URL to the waveform JSON data |
| `userName` / `userUrl` | Creator username and profile URL |
| `userFollowersCount` / `userVerified` | Creator follower count and verified flag (when `includeUserDetails`) |

**Playlist data** (`type: "playlist"`)

| Field | Description |
|-------|-------------|
| `title` | Playlist name |
| `url` | Full SoundCloud URL |
| `artworkUrl` | Cover art image URL |
| `description` | Playlist description |
| `genre` | Genre classification |
| `duration` | Total duration in milliseconds |
| `trackCount` | Number of tracks |
| `likesCount` / `repostsCount` | Total likes and reposts |
| `isAlbum` | Whether it is a released album vs a playlist |
| `publishedAt` | Publication date |
| `userName` | Creator username |

**User / artist data** (`type: "user"`)

| Field | Description |
|-------|-------------|
| `username` / `fullName` | SoundCloud username and display name |
| `url` / `avatarUrl` | Profile URL and profile picture URL |
| `description` | Bio text |
| `city` / `countryCode` | Location |
| `followersCount` / `followingsCount` | Follower and following counts |
| `trackCount` / `playlistCount` | Number of uploaded tracks and playlists |
| `likesCount` | Total likes given |
| `verified` | Verification status |
| `isPro` | Whether the account holds a SoundCloud Pro subscription |

### Output example

Track (`searchTracks` / `trackUrl` modes):

```json
{
  "type": "track",
  "id": 417474360,
  "title": "Chill Study Beats - Lofi Hip Hop Mix",
  "url": "https://soundcloud.com/nigeldelviero/chill-study-beats-lofi-hip-hop-mix",
  "artworkUrl": "https://i1.sndcdn.com/artworks-000321524016-jw118f-large.jpg",
  "genre": "Hip-hop & Rap",
  "tagList": ["Lo-Fi", "Relax", "Chill"],
  "duration": 7200255,
  "playbackCount": 4732814,
  "likesCount": 93032,
  "repostsCount": 2211,
  "commentCount": 4802,
  "downloadable": false,
  "streamable": true,
  "license": "all-rights-reserved",
  "createdAt": "2018-03-22T08:35:48Z",
  "isrc": null,
  "userName": "nigeldelviero",
  "userUrl": "https://soundcloud.com/nigeldelviero",
  "userFollowersCount": 4056,
  "userVerified": false,
  "scrapedAt": "2026-09-03T00:00:00.000Z"
}
```

User (`searchUsers` / `userUrl` modes):

```json
{
  "type": "user",
  "id": 203410014,
  "username": "deadmau5",
  "fullName": "deadmau5",
  "url": "https://soundcloud.com/deadmau5",
  "followersCount": 384482,
  "followingsCount": 3,
  "trackCount": 392,
  "playlistCount": 78,
  "verified": true,
  "isPro": true
}
```

Download the dataset in **JSON, CSV, Excel, HTML, or RSS** from the **Storage** tab or via the API.

### How to scrape SoundCloud

1. Open the Actor and go to the **Input** tab.
2. Choose a **Mode**.
3. Fill the field that mode needs:
   - `searchTracks`, `searchPlaylists`, `searchUsers` → **Search queries** (one term per line).
   - `trackUrl`, `playlistUrl`, `userUrl` → **SoundCloud URLs**.
4. Set **Max results**. Keep it low for the first run; use `0` for unlimited.
5. For `playlistUrl` mode, toggle **Include playlist child tracks** to expand a playlist into its tracks.
6. Click **Start**. When the run finishes, open the **Storage** tab and export as JSON, CSV, or Excel.

#### Run from the Apify API — Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("parsebird/soundcloud-scraper").call(run_input={
    "mode": "userUrl",
    "startUrls": ["https://soundcloud.com/flume"],
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["type"], item.get("title") or item.get("username"), item.get("playbackCount"))
```

#### Run from the Apify API — JavaScript

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('parsebird/soundcloud-scraper').call({
    mode: 'playlistUrl',
    startUrls: ['https://soundcloud.com/user/sets/my-playlist'],
    includePlaylistTracks: true,
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

The actor also works over plain [HTTP](https://docs.apify.com/api/v2/act-runs-post) and as an [MCP](https://mcp.apify.com) tool for AI assistants.

### How it works

1. **Validate input** — the actor checks the mode and the field it requires (search queries or URLs).
2. **Resolve a session** — it reads a public `client_id` from SoundCloud's own JavaScript and caches it, refreshing automatically if SoundCloud rotates it.
3. **Query api-v2** — search endpoints are paginated in pages of 200; URLs are resolved through `/resolve`; artist tracks and playlist child tracks are fetched and, where SoundCloud returns partial rows, hydrated in batches.
4. **Normalize** — nested API objects are flattened into clean, consistent `track`, `playlist`, and `user` records.
5. **Push and charge** — each record is written to the dataset and charged once (see Pricing). Unknown or private URLs are logged and skipped; the run continues.

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

Pricing is **pay-per-result**: one charge per record written to the dataset (a track, playlist, or user row).

| Plan | Price per 1,000 results |
|------|-------------------------|
| Free | **$1.79** |
| Bronze | **$1.49** |
| Silver | **$1.29** |
| Gold | **$1.09** |

Scraping 1,000 tracks costs about **$1.79** on the Free plan. A playlist with 200 child tracks costs about **$0.36** (201 records). Apify's monthly free platform credits cover thousands of records. See [Apify pricing](https://apify.com/pricing).

### Is it legal to scrape SoundCloud?

Scraping publicly available data is generally legal. This Actor accesses only public data through SoundCloud's own public API endpoints — the same data any visitor sees on soundcloud.com — and never logs in or bypasses access controls. You are responsible for how you use the data: comply with SoundCloud's Terms of Service, respect artists' rights, and follow data-protection laws such as GDPR and CCPA when the data includes personal information. For background, read the Apify blog on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Related actors

- [Spotify Play Count Scraper](https://apify.com/parsebird/spotify-play-count-scraper) — track, album, and artist play counts from Spotify.
- [Apple Podcasts Scraper](https://apify.com/parsebird/apple-podcasts-scraper) — podcast shows and episodes from Apple Podcasts.
- [Resident Advisor Scraper](https://apify.com/parsebird/resident-advisor-scraper) — electronic music events, clubs, and artists from RA.
- [YouTube Transcript Scraper](https://apify.com/parsebird/youtube-transcript-scraper) — transcripts and captions from YouTube videos.

Browse all [ParseBird actors](https://apify.com/parsebird).

### FAQ

**Do I need a SoundCloud account or API key?**
No. The Actor uses SoundCloud's public `api-v2` endpoints with the same `client_id` the website ships to every visitor. Nothing is logged in.

**How many results can I get?**
URL modes return one row per track, plus child tracks for playlists and uploaded tracks for artists (bounded by `maxResults`, `0` = unlimited). Search modes return everything SoundCloud's search exposes for a query — in practice a few hundred results per term, since SoundCloud caps how deep its search pages go.

**Can I get every track in a large playlist?**
Yes. Use `playlistUrl` mode with **Include playlist child tracks** enabled and `maxResults` set to `0`. The playlist metadata row is always emitted first.

**Why is a track or profile missing?**
Private, deleted, or region-blocked tracks cannot be scraped. Unresolvable URLs are logged as warnings and skipped so the rest of the run completes.

**Does it download audio files?**
No. The Actor returns metadata, artwork URLs, and waveform-data URLs — not audio.

**Can I schedule this to track plays and followers over time?**
Yes. Use Apify [Schedules](https://docs.apify.com/platform/schedules) to run daily and record `playbackCount`, `likesCount`, and `followersCount` for trend analysis.

**Something's not working — how do I report it?**
Open an issue on the Actor's **Issues** tab with your input and what you expected. Feedback is welcome.

# Actor input Schema

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

What to scrape.

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

Search terms for the search modes. One query per line (e.g. a genre, artist name, or keyword).

## `startUrls` (type: `array`):

SoundCloud URLs for the URL modes — track, playlist (/sets/), or user/artist profile URLs. Used by 'Track by URL', 'Playlist by URL', and 'User / artist by URL'.

## `maxResults` (type: `integer`):

Maximum items to extract per query or URL. Use 0 for unlimited. In 'Playlist by URL' mode this limits child tracks per playlist (the playlist metadata row is always emitted).

## `includeUserDetails` (type: `boolean`):

Attach the creator's follower count, verified status, and profile URL to each track result.

## `includePlaylistTracks` (type: `boolean`):

In 'Playlist by URL' mode, emit each public track inside the playlist after the playlist metadata row.

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

SoundCloud works from Apify's datacenter proxy. Switch to residential IPs for very large runs.

## Actor input object example

```json
{
  "mode": "searchTracks",
  "searchQueries": [
    "ambient techno",
    "dark jazz"
  ],
  "startUrls": [
    "https://soundcloud.com/flume/say-nothing-feat-may-a"
  ],
  "maxResults": 25,
  "includeUserDetails": true,
  "includePlaylistTracks": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "mode": "searchTracks",
    "searchQueries": [
        "ambient techno",
        "dark jazz"
    ],
    "startUrls": [
        "https://soundcloud.com/flume/say-nothing-feat-may-a"
    ],
    "maxResults": 25,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "mode": "searchTracks",
    "searchQueries": [
        "ambient techno",
        "dark jazz",
    ],
    "startUrls": ["https://soundcloud.com/flume/say-nothing-feat-may-a"],
    "maxResults": 25,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/soundcloud-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "searchTracks",
  "searchQueries": [
    "ambient techno",
    "dark jazz"
  ],
  "startUrls": [
    "https://soundcloud.com/flume/say-nothing-feat-may-a"
  ],
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call parsebird/soundcloud-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/soundcloud-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Tap212OsebGS1o5L4/builds/pcRwhODnbHS03b49R/openapi.json